// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

/// A dyn-compatible, crate-private version of [super::AcceleratorTypes].
#[cfg(feature = "accelerator-types")]
#[async_trait::async_trait]
pub trait AcceleratorTypes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::accelerator_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorTypeAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::accelerator_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorType>>;

    async fn list(
        &self,
        req: crate::model::accelerator_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorTypeList>>;
}

/// All implementations of [super::AcceleratorTypes] also implement [AcceleratorTypes].
#[cfg(feature = "accelerator-types")]
#[async_trait::async_trait]
impl<T: super::AcceleratorTypes> AcceleratorTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::accelerator_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorTypeAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::accelerator_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::accelerator_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AcceleratorTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Addresses].
#[cfg(feature = "addresses")]
#[async_trait::async_trait]
pub trait Addresses: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::addresses::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::addresses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::addresses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Address>>;

    async fn insert(
        &self,
        req: crate::model::addresses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::addresses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressList>>;

    async fn r#move(
        &self,
        req: crate::model::addresses::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::addresses::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::addresses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Addresses] also implement [Addresses].
#[cfg(feature = "addresses")]
#[async_trait::async_trait]
impl<T: super::Addresses> Addresses for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::addresses::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::addresses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::addresses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Address>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::addresses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::addresses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn r#move(
        &self,
        req: crate::model::addresses::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::r#move(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::addresses::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::addresses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Advice].
#[cfg(feature = "advice")]
#[async_trait::async_trait]
pub trait Advice: std::fmt::Debug + Send + Sync {
    async fn calendar_mode(
        &self,
        req: crate::model::advice::CalendarModeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CalendarModeAdviceResponse>>;
}

/// All implementations of [super::Advice] also implement [Advice].
#[cfg(feature = "advice")]
#[async_trait::async_trait]
impl<T: super::Advice> Advice for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn calendar_mode(
        &self,
        req: crate::model::advice::CalendarModeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CalendarModeAdviceResponse>> {
        T::calendar_mode(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Autoscalers].
#[cfg(feature = "autoscalers")]
#[async_trait::async_trait]
pub trait Autoscalers: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::autoscalers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AutoscalerAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::autoscalers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::autoscalers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Autoscaler>>;

    async fn insert(
        &self,
        req: crate::model::autoscalers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::autoscalers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AutoscalerList>>;

    async fn patch(
        &self,
        req: crate::model::autoscalers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::autoscalers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Autoscalers] also implement [Autoscalers].
#[cfg(feature = "autoscalers")]
#[async_trait::async_trait]
impl<T: super::Autoscalers> Autoscalers for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::autoscalers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AutoscalerAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::autoscalers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::autoscalers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Autoscaler>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::autoscalers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::autoscalers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AutoscalerList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::autoscalers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::autoscalers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::BackendBuckets].
#[cfg(feature = "backend-buckets")]
#[async_trait::async_trait]
pub trait BackendBuckets: std::fmt::Debug + Send + Sync {
    async fn add_signed_url_key(
        &self,
        req: crate::model::backend_buckets::AddSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::backend_buckets::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_signed_url_key(
        &self,
        req: crate::model::backend_buckets::DeleteSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::backend_buckets::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendBucket>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::backend_buckets::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::backend_buckets::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::backend_buckets::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendBucketList>>;

    async fn patch(
        &self,
        req: crate::model::backend_buckets::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_edge_security_policy(
        &self,
        req: crate::model::backend_buckets::SetEdgeSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::backend_buckets::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::backend_buckets::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::backend_buckets::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::BackendBuckets] also implement [BackendBuckets].
#[cfg(feature = "backend-buckets")]
#[async_trait::async_trait]
impl<T: super::BackendBuckets> BackendBuckets for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_signed_url_key(
        &self,
        req: crate::model::backend_buckets::AddSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_signed_url_key(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::backend_buckets::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_signed_url_key(
        &self,
        req: crate::model::backend_buckets::DeleteSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_signed_url_key(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::backend_buckets::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendBucket>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::backend_buckets::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::backend_buckets::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::backend_buckets::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendBucketList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::backend_buckets::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_edge_security_policy(
        &self,
        req: crate::model::backend_buckets::SetEdgeSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_edge_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::backend_buckets::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::backend_buckets::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::backend_buckets::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::BackendServices].
#[cfg(feature = "backend-services")]
#[async_trait::async_trait]
pub trait BackendServices: std::fmt::Debug + Send + Sync {
    async fn add_signed_url_key(
        &self,
        req: crate::model::backend_services::AddSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::backend_services::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::backend_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_signed_url_key(
        &self,
        req: crate::model::backend_services::DeleteSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::backend_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendService>>;

    async fn get_effective_security_policies(
        &self,
        req: crate::model::backend_services::GetEffectiveSecurityPoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn get_health(
        &self,
        req: crate::model::backend_services::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::backend_services::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::backend_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::backend_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceList>>;

    async fn list_usable(
        &self,
        req: crate::model::backend_services::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>>;

    async fn patch(
        &self,
        req: crate::model::backend_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_edge_security_policy(
        &self,
        req: crate::model::backend_services::SetEdgeSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::backend_services::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_security_policy(
        &self,
        req: crate::model::backend_services::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::backend_services::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::backend_services::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::BackendServices] also implement [BackendServices].
#[cfg(feature = "backend-services")]
#[async_trait::async_trait]
impl<T: super::BackendServices> BackendServices for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_signed_url_key(
        &self,
        req: crate::model::backend_services::AddSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_signed_url_key(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::backend_services::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::backend_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_signed_url_key(
        &self,
        req: crate::model::backend_services::DeleteSignedUrlKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_signed_url_key(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::backend_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendService>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_effective_security_policies(
        &self,
        req: crate::model::backend_services::GetEffectiveSecurityPoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::get_effective_security_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_health(
        &self,
        req: crate::model::backend_services::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>> {
        T::get_health(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::backend_services::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::backend_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::backend_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_usable(
        &self,
        req: crate::model::backend_services::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>> {
        T::list_usable(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::backend_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_edge_security_policy(
        &self,
        req: crate::model::backend_services::SetEdgeSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_edge_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::backend_services::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_security_policy(
        &self,
        req: crate::model::backend_services::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::backend_services::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::backend_services::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::CrossSiteNetworks].
#[cfg(feature = "cross-site-networks")]
#[async_trait::async_trait]
pub trait CrossSiteNetworks: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::cross_site_networks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::cross_site_networks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CrossSiteNetwork>>;

    async fn insert(
        &self,
        req: crate::model::cross_site_networks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::cross_site_networks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CrossSiteNetworkList>>;

    async fn patch(
        &self,
        req: crate::model::cross_site_networks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::CrossSiteNetworks] also implement [CrossSiteNetworks].
#[cfg(feature = "cross-site-networks")]
#[async_trait::async_trait]
impl<T: super::CrossSiteNetworks> CrossSiteNetworks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::cross_site_networks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::cross_site_networks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CrossSiteNetwork>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::cross_site_networks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::cross_site_networks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CrossSiteNetworkList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::cross_site_networks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::DiskTypes].
#[cfg(feature = "disk-types")]
#[async_trait::async_trait]
pub trait DiskTypes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::disk_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskTypeAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::disk_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskType>>;

    async fn list(
        &self,
        req: crate::model::disk_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskTypeList>>;
}

/// All implementations of [super::DiskTypes] also implement [DiskTypes].
#[cfg(feature = "disk-types")]
#[async_trait::async_trait]
impl<T: super::DiskTypes> DiskTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::disk_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskTypeAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::disk_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::disk_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Disks].
#[cfg(feature = "disks")]
#[async_trait::async_trait]
pub trait Disks: std::fmt::Debug + Send + Sync {
    async fn add_resource_policies(
        &self,
        req: crate::model::disks::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::disks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskAggregatedList>>;

    async fn bulk_insert(
        &self,
        req: crate::model::disks::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn bulk_set_labels(
        &self,
        req: crate::model::disks::BulkSetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn create_snapshot(
        &self,
        req: crate::model::disks::CreateSnapshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::disks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::disks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Disk>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::disks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::disks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::disks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskList>>;

    async fn remove_resource_policies(
        &self,
        req: crate::model::disks::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resize(
        &self,
        req: crate::model::disks::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::disks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::disks::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start_async_replication(
        &self,
        req: crate::model::disks::StartAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_async_replication(
        &self,
        req: crate::model::disks::StopAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_group_async_replication(
        &self,
        req: crate::model::disks::StopGroupAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::disks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::disks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Disks] also implement [Disks].
#[cfg(feature = "disks")]
#[async_trait::async_trait]
impl<T: super::Disks> Disks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_resource_policies(
        &self,
        req: crate::model::disks::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::disks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn bulk_insert(
        &self,
        req: crate::model::disks::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::bulk_insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn bulk_set_labels(
        &self,
        req: crate::model::disks::BulkSetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::bulk_set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn create_snapshot(
        &self,
        req: crate::model::disks::CreateSnapshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::create_snapshot(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::disks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::disks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Disk>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::disks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::disks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::disks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_resource_policies(
        &self,
        req: crate::model::disks::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resize(
        &self,
        req: crate::model::disks::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resize(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::disks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::disks::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_async_replication(
        &self,
        req: crate::model::disks::StartAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_async_replication(
        &self,
        req: crate::model::disks::StopAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_group_async_replication(
        &self,
        req: crate::model::disks::StopGroupAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_group_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::disks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::disks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ExternalVpnGateways].
#[cfg(feature = "external-vpn-gateways")]
#[async_trait::async_trait]
pub trait ExternalVpnGateways: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::external_vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::external_vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExternalVpnGateway>>;

    async fn insert(
        &self,
        req: crate::model::external_vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::external_vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExternalVpnGatewayList>>;

    async fn set_labels(
        &self,
        req: crate::model::external_vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::external_vpn_gateways::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ExternalVpnGateways] also implement [ExternalVpnGateways].
#[cfg(feature = "external-vpn-gateways")]
#[async_trait::async_trait]
impl<T: super::ExternalVpnGateways> ExternalVpnGateways for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::external_vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::external_vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExternalVpnGateway>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::external_vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::external_vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExternalVpnGatewayList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::external_vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::external_vpn_gateways::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::FirewallPolicies].
#[cfg(feature = "firewall-policies")]
#[async_trait::async_trait]
pub trait FirewallPolicies: std::fmt::Debug + Send + Sync {
    async fn add_association(
        &self,
        req: crate::model::firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_rule(
        &self,
        req: crate::model::firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn clone_rules(
        &self,
        req: crate::model::firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>>;

    async fn get_association(
        &self,
        req: crate::model::firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_rule(
        &self,
        req: crate::model::firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>;

    async fn list_associations(
        &self,
        req: crate::model::firewall_policies::ListAssociationsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::FirewallPoliciesListAssociationsResponse>,
    >;

    async fn r#move(
        &self,
        req: crate::model::firewall_policies::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch(
        &self,
        req: crate::model::firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_association(
        &self,
        req: crate::model::firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::FirewallPolicies] also implement [FirewallPolicies].
#[cfg(feature = "firewall-policies")]
#[async_trait::async_trait]
impl<T: super::FirewallPolicies> FirewallPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_association(
        &self,
        req: crate::model::firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn clone_rules(
        &self,
        req: crate::model::firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::clone_rules(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_association(
        &self,
        req: crate::model::firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>> {
        T::get_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_associations(
        &self,
        req: crate::model::firewall_policies::ListAssociationsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::FirewallPoliciesListAssociationsResponse>,
    > {
        T::list_associations(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn r#move(
        &self,
        req: crate::model::firewall_policies::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::r#move(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_association(
        &self,
        req: crate::model::firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Firewalls].
#[cfg(feature = "firewalls")]
#[async_trait::async_trait]
pub trait Firewalls: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::firewalls::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::firewalls::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Firewall>>;

    async fn insert(
        &self,
        req: crate::model::firewalls::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::firewalls::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallList>>;

    async fn patch(
        &self,
        req: crate::model::firewalls::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::firewalls::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::firewalls::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Firewalls] also implement [Firewalls].
#[cfg(feature = "firewalls")]
#[async_trait::async_trait]
impl<T: super::Firewalls> Firewalls for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::firewalls::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::firewalls::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Firewall>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::firewalls::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::firewalls::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::firewalls::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::firewalls::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::firewalls::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ForwardingRules].
#[cfg(feature = "forwarding-rules")]
#[async_trait::async_trait]
pub trait ForwardingRules: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::forwarding_rules::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::forwarding_rules::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::forwarding_rules::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRule>>;

    async fn insert(
        &self,
        req: crate::model::forwarding_rules::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::forwarding_rules::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleList>>;

    async fn patch(
        &self,
        req: crate::model::forwarding_rules::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::forwarding_rules::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_target(
        &self,
        req: crate::model::forwarding_rules::SetTargetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ForwardingRules] also implement [ForwardingRules].
#[cfg(feature = "forwarding-rules")]
#[async_trait::async_trait]
impl<T: super::ForwardingRules> ForwardingRules for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::forwarding_rules::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::forwarding_rules::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::forwarding_rules::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRule>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::forwarding_rules::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::forwarding_rules::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::forwarding_rules::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::forwarding_rules::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_target(
        &self,
        req: crate::model::forwarding_rules::SetTargetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_target(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::FutureReservations].
#[cfg(feature = "future-reservations")]
#[async_trait::async_trait]
pub trait FutureReservations: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::future_reservations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::FutureReservationsAggregatedListResponse>,
    >;

    async fn cancel(
        &self,
        req: crate::model::future_reservations::CancelRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::future_reservations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::future_reservations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FutureReservation>>;

    async fn insert(
        &self,
        req: crate::model::future_reservations::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::future_reservations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FutureReservationsListResponse>>;

    async fn update(
        &self,
        req: crate::model::future_reservations::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::FutureReservations] also implement [FutureReservations].
#[cfg(feature = "future-reservations")]
#[async_trait::async_trait]
impl<T: super::FutureReservations> FutureReservations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::future_reservations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::FutureReservationsAggregatedListResponse>,
    > {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn cancel(
        &self,
        req: crate::model::future_reservations::CancelRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::cancel(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::future_reservations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::future_reservations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FutureReservation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::future_reservations::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::future_reservations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FutureReservationsListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::future_reservations::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalAddresses].
#[cfg(feature = "global-addresses")]
#[async_trait::async_trait]
pub trait GlobalAddresses: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::global_addresses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::global_addresses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Address>>;

    async fn insert(
        &self,
        req: crate::model::global_addresses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_addresses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressList>>;

    async fn r#move(
        &self,
        req: crate::model::global_addresses::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::global_addresses::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::global_addresses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::GlobalAddresses] also implement [GlobalAddresses].
#[cfg(feature = "global-addresses")]
#[async_trait::async_trait]
impl<T: super::GlobalAddresses> GlobalAddresses for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_addresses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_addresses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Address>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::global_addresses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_addresses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::AddressList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn r#move(
        &self,
        req: crate::model::global_addresses::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::r#move(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::global_addresses::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::global_addresses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalForwardingRules].
#[cfg(feature = "global-forwarding-rules")]
#[async_trait::async_trait]
pub trait GlobalForwardingRules: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::global_forwarding_rules::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::global_forwarding_rules::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRule>>;

    async fn insert(
        &self,
        req: crate::model::global_forwarding_rules::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_forwarding_rules::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleList>>;

    async fn patch(
        &self,
        req: crate::model::global_forwarding_rules::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::global_forwarding_rules::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_target(
        &self,
        req: crate::model::global_forwarding_rules::SetTargetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::GlobalForwardingRules] also implement [GlobalForwardingRules].
#[cfg(feature = "global-forwarding-rules")]
#[async_trait::async_trait]
impl<T: super::GlobalForwardingRules> GlobalForwardingRules for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_forwarding_rules::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_forwarding_rules::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRule>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::global_forwarding_rules::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_forwarding_rules::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ForwardingRuleList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::global_forwarding_rules::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::global_forwarding_rules::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_target(
        &self,
        req: crate::model::global_forwarding_rules::SetTargetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_target(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalNetworkEndpointGroups].
#[cfg(feature = "global-network-endpoint-groups")]
#[async_trait::async_trait]
pub trait GlobalNetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    async fn attach_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::global_network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn detach_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::global_network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>;

    async fn insert(
        &self,
        req: crate::model::global_network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>;

    async fn list_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    >;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::GlobalNetworkEndpointGroups] also implement [GlobalNetworkEndpointGroups].
#[cfg(feature = "global-network-endpoint-groups")]
#[async_trait::async_trait]
impl<T: super::GlobalNetworkEndpointGroups> GlobalNetworkEndpointGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn attach_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::attach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn detach_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::detach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::global_network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_network_endpoints(
        &self,
        req: crate::model::global_network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    > {
        T::list_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalOperations].
#[cfg(feature = "global-operations")]
#[async_trait::async_trait]
pub trait GlobalOperations: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::global_operations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::global_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn get(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>>;

    async fn wait(
        &self,
        req: crate::model::global_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;
}

/// All implementations of [super::GlobalOperations] also implement [GlobalOperations].
#[cfg(feature = "global-operations")]
#[async_trait::async_trait]
impl<T: super::GlobalOperations> GlobalOperations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::global_operations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn wait(
        &self,
        req: crate::model::global_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::wait(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalOrganizationOperations].
#[cfg(feature = "global-organization-operations")]
#[async_trait::async_trait]
pub trait GlobalOrganizationOperations: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::global_organization_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn get(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_organization_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>>;
}

/// All implementations of [super::GlobalOrganizationOperations] also implement [GlobalOrganizationOperations].
#[cfg(feature = "global-organization-operations")]
#[async_trait::async_trait]
impl<T: super::GlobalOrganizationOperations> GlobalOrganizationOperations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_organization_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_organization_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::GlobalPublicDelegatedPrefixes].
#[cfg(feature = "global-public-delegated-prefixes")]
#[async_trait::async_trait]
pub trait GlobalPublicDelegatedPrefixes: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::global_public_delegated_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::global_public_delegated_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>>;

    async fn insert(
        &self,
        req: crate::model::global_public_delegated_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::global_public_delegated_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>>;

    async fn patch(
        &self,
        req: crate::model::global_public_delegated_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::GlobalPublicDelegatedPrefixes] also implement [GlobalPublicDelegatedPrefixes].
#[cfg(feature = "global-public-delegated-prefixes")]
#[async_trait::async_trait]
impl<T: super::GlobalPublicDelegatedPrefixes> GlobalPublicDelegatedPrefixes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::global_public_delegated_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::global_public_delegated_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::global_public_delegated_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::global_public_delegated_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::global_public_delegated_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::HealthChecks].
#[cfg(feature = "health-checks")]
#[async_trait::async_trait]
pub trait HealthChecks: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::health_checks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthChecksAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheck>>;

    async fn insert(
        &self,
        req: crate::model::health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckList>>;

    async fn patch(
        &self,
        req: crate::model::health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::HealthChecks] also implement [HealthChecks].
#[cfg(feature = "health-checks")]
#[async_trait::async_trait]
impl<T: super::HealthChecks> HealthChecks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::health_checks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthChecksAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheck>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::HttpHealthChecks].
#[cfg(feature = "http-health-checks")]
#[async_trait::async_trait]
pub trait HttpHealthChecks: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::http_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::http_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpHealthCheck>>;

    async fn insert(
        &self,
        req: crate::model::http_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::http_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpHealthCheckList>>;

    async fn patch(
        &self,
        req: crate::model::http_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::http_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::HttpHealthChecks] also implement [HttpHealthChecks].
#[cfg(feature = "http-health-checks")]
#[async_trait::async_trait]
impl<T: super::HttpHealthChecks> HttpHealthChecks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::http_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::http_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpHealthCheck>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::http_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::http_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpHealthCheckList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::http_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::http_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::HttpsHealthChecks].
#[cfg(feature = "https-health-checks")]
#[async_trait::async_trait]
pub trait HttpsHealthChecks: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::https_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::https_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpsHealthCheck>>;

    async fn insert(
        &self,
        req: crate::model::https_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::https_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpsHealthCheckList>>;

    async fn patch(
        &self,
        req: crate::model::https_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::https_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::HttpsHealthChecks] also implement [HttpsHealthChecks].
#[cfg(feature = "https-health-checks")]
#[async_trait::async_trait]
impl<T: super::HttpsHealthChecks> HttpsHealthChecks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::https_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::https_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpsHealthCheck>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::https_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::https_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HttpsHealthCheckList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::https_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::https_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ImageFamilyViews].
#[cfg(feature = "image-family-views")]
#[async_trait::async_trait]
pub trait ImageFamilyViews: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::image_family_views::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ImageFamilyView>>;
}

/// All implementations of [super::ImageFamilyViews] also implement [ImageFamilyViews].
#[cfg(feature = "image-family-views")]
#[async_trait::async_trait]
impl<T: super::ImageFamilyViews> ImageFamilyViews for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::image_family_views::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ImageFamilyView>> {
        T::get(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Images].
#[cfg(feature = "images")]
#[async_trait::async_trait]
pub trait Images: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::images::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn deprecate(
        &self,
        req: crate::model::images::DeprecateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::images::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Image>>;

    async fn get_from_family(
        &self,
        req: crate::model::images::GetFromFamilyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Image>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::images::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::images::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::images::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ImageList>>;

    async fn patch(
        &self,
        req: crate::model::images::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::images::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::images::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::images::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Images] also implement [Images].
#[cfg(feature = "images")]
#[async_trait::async_trait]
impl<T: super::Images> Images for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::images::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn deprecate(
        &self,
        req: crate::model::images::DeprecateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::deprecate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::images::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Image>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_from_family(
        &self,
        req: crate::model::images::GetFromFamilyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Image>> {
        T::get_from_family(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::images::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::images::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::images::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ImageList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::images::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::images::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::images::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::images::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstanceGroupManagerResizeRequests].
#[cfg(feature = "instance-group-manager-resize-requests")]
#[async_trait::async_trait]
pub trait InstanceGroupManagerResizeRequests: std::fmt::Debug + Send + Sync {
    async fn cancel(
        &self,
        req: crate::model::instance_group_manager_resize_requests::CancelRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::instance_group_manager_resize_requests::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instance_group_manager_resize_requests::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerResizeRequest>>;

    async fn insert(
        &self,
        req: crate::model::instance_group_manager_resize_requests::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instance_group_manager_resize_requests::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagerResizeRequestsListResponse>,
    >;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstanceGroupManagerResizeRequests] also implement [InstanceGroupManagerResizeRequests].
#[cfg(feature = "instance-group-manager-resize-requests")]
#[async_trait::async_trait]
impl<T: super::InstanceGroupManagerResizeRequests> InstanceGroupManagerResizeRequests for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn cancel(
        &self,
        req: crate::model::instance_group_manager_resize_requests::CancelRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::cancel(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instance_group_manager_resize_requests::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instance_group_manager_resize_requests::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerResizeRequest>>
    {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instance_group_manager_resize_requests::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instance_group_manager_resize_requests::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagerResizeRequestsListResponse>,
    > {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstanceGroupManagers].
#[cfg(feature = "instance-group-managers")]
#[async_trait::async_trait]
pub trait InstanceGroupManagers: std::fmt::Debug + Send + Sync {
    async fn abandon_instances(
        &self,
        req: crate::model::instance_group_managers::AbandonInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::instance_group_managers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerAggregatedList>>;

    async fn apply_updates_to_instances(
        &self,
        req: crate::model::instance_group_managers::ApplyUpdatesToInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn create_instances(
        &self,
        req: crate::model::instance_group_managers::CreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::instance_group_managers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_instances(
        &self,
        req: crate::model::instance_group_managers::DeleteInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::DeletePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instance_group_managers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManager>>;

    async fn insert(
        &self,
        req: crate::model::instance_group_managers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instance_group_managers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerList>>;

    async fn list_errors(
        &self,
        req: crate::model::instance_group_managers::ListErrorsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagersListErrorsResponse>>;

    async fn list_managed_instances(
        &self,
        req: crate::model::instance_group_managers::ListManagedInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagersListManagedInstancesResponse>,
    >;

    async fn list_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::ListPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagersListPerInstanceConfigsResp>,
    >;

    async fn patch(
        &self,
        req: crate::model::instance_group_managers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::PatchPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn recreate_instances(
        &self,
        req: crate::model::instance_group_managers::RecreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resize(
        &self,
        req: crate::model::instance_group_managers::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resume_instances(
        &self,
        req: crate::model::instance_group_managers::ResumeInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_instance_template(
        &self,
        req: crate::model::instance_group_managers::SetInstanceTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_target_pools(
        &self,
        req: crate::model::instance_group_managers::SetTargetPoolsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start_instances(
        &self,
        req: crate::model::instance_group_managers::StartInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_instances(
        &self,
        req: crate::model::instance_group_managers::StopInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn suspend_instances(
        &self,
        req: crate::model::instance_group_managers::SuspendInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::UpdatePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstanceGroupManagers] also implement [InstanceGroupManagers].
#[cfg(feature = "instance-group-managers")]
#[async_trait::async_trait]
impl<T: super::InstanceGroupManagers> InstanceGroupManagers for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn abandon_instances(
        &self,
        req: crate::model::instance_group_managers::AbandonInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::abandon_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::instance_group_managers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerAggregatedList>>
    {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn apply_updates_to_instances(
        &self,
        req: crate::model::instance_group_managers::ApplyUpdatesToInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::apply_updates_to_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn create_instances(
        &self,
        req: crate::model::instance_group_managers::CreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::create_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instance_group_managers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_instances(
        &self,
        req: crate::model::instance_group_managers::DeleteInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::DeletePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instance_group_managers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManager>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instance_group_managers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instance_group_managers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagerList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_errors(
        &self,
        req: crate::model::instance_group_managers::ListErrorsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManagersListErrorsResponse>>
    {
        T::list_errors(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_managed_instances(
        &self,
        req: crate::model::instance_group_managers::ListManagedInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagersListManagedInstancesResponse>,
    > {
        T::list_managed_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::ListPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InstanceGroupManagersListPerInstanceConfigsResp>,
    > {
        T::list_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::instance_group_managers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::PatchPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn recreate_instances(
        &self,
        req: crate::model::instance_group_managers::RecreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::recreate_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resize(
        &self,
        req: crate::model::instance_group_managers::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resize(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resume_instances(
        &self,
        req: crate::model::instance_group_managers::ResumeInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resume_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_instance_template(
        &self,
        req: crate::model::instance_group_managers::SetInstanceTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_instance_template(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_target_pools(
        &self,
        req: crate::model::instance_group_managers::SetTargetPoolsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_target_pools(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_instances(
        &self,
        req: crate::model::instance_group_managers::StartInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_instances(
        &self,
        req: crate::model::instance_group_managers::StopInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn suspend_instances(
        &self,
        req: crate::model::instance_group_managers::SuspendInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::suspend_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_per_instance_configs(
        &self,
        req: crate::model::instance_group_managers::UpdatePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstanceGroups].
#[cfg(feature = "instance-groups")]
#[async_trait::async_trait]
pub trait InstanceGroups: std::fmt::Debug + Send + Sync {
    async fn add_instances(
        &self,
        req: crate::model::instance_groups::AddInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::instance_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::instance_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instance_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroup>>;

    async fn insert(
        &self,
        req: crate::model::instance_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instance_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupList>>;

    async fn list_instances(
        &self,
        req: crate::model::instance_groups::ListInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupsListInstances>>;

    async fn remove_instances(
        &self,
        req: crate::model::instance_groups::RemoveInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_named_ports(
        &self,
        req: crate::model::instance_groups::SetNamedPortsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::instance_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstanceGroups] also implement [InstanceGroups].
#[cfg(feature = "instance-groups")]
#[async_trait::async_trait]
impl<T: super::InstanceGroups> InstanceGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_instances(
        &self,
        req: crate::model::instance_groups::AddInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::instance_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instance_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instance_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instance_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instance_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_instances(
        &self,
        req: crate::model::instance_groups::ListInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupsListInstances>> {
        T::list_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_instances(
        &self,
        req: crate::model::instance_groups::RemoveInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_named_ports(
        &self,
        req: crate::model::instance_groups::SetNamedPortsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_named_ports(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::instance_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstanceSettings].
#[cfg(feature = "instance-settings")]
#[async_trait::async_trait]
pub trait InstanceSettings: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::instance_settings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceSettings>>;

    async fn patch(
        &self,
        req: crate::model::instance_settings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstanceSettings] also implement [InstanceSettings].
#[cfg(feature = "instance-settings")]
#[async_trait::async_trait]
impl<T: super::InstanceSettings> InstanceSettings for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instance_settings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceSettings>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::instance_settings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstanceTemplates].
#[cfg(feature = "instance-templates")]
#[async_trait::async_trait]
pub trait InstanceTemplates: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::instance_templates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::instance_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instance_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplate>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::instance_templates::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::instance_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instance_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::instance_templates::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::instance_templates::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstanceTemplates] also implement [InstanceTemplates].
#[cfg(feature = "instance-templates")]
#[async_trait::async_trait]
impl<T: super::InstanceTemplates> InstanceTemplates for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::instance_templates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instance_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instance_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplate>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::instance_templates::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instance_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instance_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::instance_templates::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::instance_templates::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Instances].
#[cfg(feature = "instances")]
#[async_trait::async_trait]
pub trait Instances: std::fmt::Debug + Send + Sync {
    async fn add_access_config(
        &self,
        req: crate::model::instances::AddAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_network_interface(
        &self,
        req: crate::model::instances::AddNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_resource_policies(
        &self,
        req: crate::model::instances::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::instances::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceAggregatedList>>;

    async fn attach_disk(
        &self,
        req: crate::model::instances::AttachDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn bulk_insert(
        &self,
        req: crate::model::instances::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::instances::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_access_config(
        &self,
        req: crate::model::instances::DeleteAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_network_interface(
        &self,
        req: crate::model::instances::DeleteNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn detach_disk(
        &self,
        req: crate::model::instances::DetachDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instances::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Instance>>;

    async fn get_effective_firewalls(
        &self,
        req: crate::model::instances::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstancesGetEffectiveFirewallsResponse>>;

    async fn get_guest_attributes(
        &self,
        req: crate::model::instances::GetGuestAttributesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::GuestAttributes>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::instances::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_screenshot(
        &self,
        req: crate::model::instances::GetScreenshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Screenshot>>;

    async fn get_serial_port_output(
        &self,
        req: crate::model::instances::GetSerialPortOutputRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SerialPortOutput>>;

    async fn get_shielded_instance_identity(
        &self,
        req: crate::model::instances::GetShieldedInstanceIdentityRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ShieldedInstanceIdentity>>;

    async fn insert(
        &self,
        req: crate::model::instances::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instances::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceList>>;

    async fn list_referrers(
        &self,
        req: crate::model::instances::ListReferrersRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceListReferrers>>;

    async fn perform_maintenance(
        &self,
        req: crate::model::instances::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_resource_policies(
        &self,
        req: crate::model::instances::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn report_host_as_faulty(
        &self,
        req: crate::model::instances::ReportHostAsFaultyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn reset(
        &self,
        req: crate::model::instances::ResetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resume(
        &self,
        req: crate::model::instances::ResumeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn send_diagnostic_interrupt(
        &self,
        req: crate::model::instances::SendDiagnosticInterruptRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn set_deletion_protection(
        &self,
        req: crate::model::instances::SetDeletionProtectionRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_disk_auto_delete(
        &self,
        req: crate::model::instances::SetDiskAutoDeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::instances::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::instances::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_machine_resources(
        &self,
        req: crate::model::instances::SetMachineResourcesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_machine_type(
        &self,
        req: crate::model::instances::SetMachineTypeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_metadata(
        &self,
        req: crate::model::instances::SetMetadataRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_min_cpu_platform(
        &self,
        req: crate::model::instances::SetMinCpuPlatformRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_name(
        &self,
        req: crate::model::instances::SetNameRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_scheduling(
        &self,
        req: crate::model::instances::SetSchedulingRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_security_policy(
        &self,
        req: crate::model::instances::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_service_account(
        &self,
        req: crate::model::instances::SetServiceAccountRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_shielded_instance_integrity_policy(
        &self,
        req: crate::model::instances::SetShieldedInstanceIntegrityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_tags(
        &self,
        req: crate::model::instances::SetTagsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn simulate_maintenance_event(
        &self,
        req: crate::model::instances::SimulateMaintenanceEventRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start(
        &self,
        req: crate::model::instances::StartRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start_with_encryption_key(
        &self,
        req: crate::model::instances::StartWithEncryptionKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop(
        &self,
        req: crate::model::instances::StopRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn suspend(
        &self,
        req: crate::model::instances::SuspendRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::instances::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::instances::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_access_config(
        &self,
        req: crate::model::instances::UpdateAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_display_device(
        &self,
        req: crate::model::instances::UpdateDisplayDeviceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_network_interface(
        &self,
        req: crate::model::instances::UpdateNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_shielded_instance_config(
        &self,
        req: crate::model::instances::UpdateShieldedInstanceConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Instances] also implement [Instances].
#[cfg(feature = "instances")]
#[async_trait::async_trait]
impl<T: super::Instances> Instances for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_access_config(
        &self,
        req: crate::model::instances::AddAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_access_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_network_interface(
        &self,
        req: crate::model::instances::AddNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_network_interface(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_resource_policies(
        &self,
        req: crate::model::instances::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::instances::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn attach_disk(
        &self,
        req: crate::model::instances::AttachDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::attach_disk(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn bulk_insert(
        &self,
        req: crate::model::instances::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::bulk_insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instances::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_access_config(
        &self,
        req: crate::model::instances::DeleteAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_access_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_network_interface(
        &self,
        req: crate::model::instances::DeleteNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_network_interface(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn detach_disk(
        &self,
        req: crate::model::instances::DetachDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::detach_disk(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instances::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Instance>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_effective_firewalls(
        &self,
        req: crate::model::instances::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstancesGetEffectiveFirewallsResponse>>
    {
        T::get_effective_firewalls(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_guest_attributes(
        &self,
        req: crate::model::instances::GetGuestAttributesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::GuestAttributes>> {
        T::get_guest_attributes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::instances::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_screenshot(
        &self,
        req: crate::model::instances::GetScreenshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Screenshot>> {
        T::get_screenshot(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_serial_port_output(
        &self,
        req: crate::model::instances::GetSerialPortOutputRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SerialPortOutput>> {
        T::get_serial_port_output(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_shielded_instance_identity(
        &self,
        req: crate::model::instances::GetShieldedInstanceIdentityRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ShieldedInstanceIdentity>> {
        T::get_shielded_instance_identity(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instances::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instances::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_referrers(
        &self,
        req: crate::model::instances::ListReferrersRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceListReferrers>> {
        T::list_referrers(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_maintenance(
        &self,
        req: crate::model::instances::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::perform_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_resource_policies(
        &self,
        req: crate::model::instances::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn report_host_as_faulty(
        &self,
        req: crate::model::instances::ReportHostAsFaultyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::report_host_as_faulty(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn reset(
        &self,
        req: crate::model::instances::ResetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::reset(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resume(
        &self,
        req: crate::model::instances::ResumeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resume(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn send_diagnostic_interrupt(
        &self,
        req: crate::model::instances::SendDiagnosticInterruptRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::send_diagnostic_interrupt(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_deletion_protection(
        &self,
        req: crate::model::instances::SetDeletionProtectionRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_deletion_protection(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_disk_auto_delete(
        &self,
        req: crate::model::instances::SetDiskAutoDeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_disk_auto_delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::instances::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::instances::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_machine_resources(
        &self,
        req: crate::model::instances::SetMachineResourcesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_machine_resources(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_machine_type(
        &self,
        req: crate::model::instances::SetMachineTypeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_machine_type(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_metadata(
        &self,
        req: crate::model::instances::SetMetadataRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_metadata(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_min_cpu_platform(
        &self,
        req: crate::model::instances::SetMinCpuPlatformRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_min_cpu_platform(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_name(
        &self,
        req: crate::model::instances::SetNameRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_name(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_scheduling(
        &self,
        req: crate::model::instances::SetSchedulingRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_scheduling(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_security_policy(
        &self,
        req: crate::model::instances::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_service_account(
        &self,
        req: crate::model::instances::SetServiceAccountRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_service_account(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_shielded_instance_integrity_policy(
        &self,
        req: crate::model::instances::SetShieldedInstanceIntegrityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_shielded_instance_integrity_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_tags(
        &self,
        req: crate::model::instances::SetTagsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_tags(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn simulate_maintenance_event(
        &self,
        req: crate::model::instances::SimulateMaintenanceEventRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::simulate_maintenance_event(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start(
        &self,
        req: crate::model::instances::StartRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_with_encryption_key(
        &self,
        req: crate::model::instances::StartWithEncryptionKeyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start_with_encryption_key(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop(
        &self,
        req: crate::model::instances::StopRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn suspend(
        &self,
        req: crate::model::instances::SuspendRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::suspend(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::instances::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::instances::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_access_config(
        &self,
        req: crate::model::instances::UpdateAccessConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_access_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_display_device(
        &self,
        req: crate::model::instances::UpdateDisplayDeviceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_display_device(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_network_interface(
        &self,
        req: crate::model::instances::UpdateNetworkInterfaceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_network_interface(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_shielded_instance_config(
        &self,
        req: crate::model::instances::UpdateShieldedInstanceConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_shielded_instance_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InstantSnapshots].
#[cfg(feature = "instant-snapshots")]
#[async_trait::async_trait]
pub trait InstantSnapshots: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::instant_snapshots::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::instant_snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::instant_snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshot>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::instant_snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::instant_snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::instant_snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::instant_snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::instant_snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::instant_snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InstantSnapshots] also implement [InstantSnapshots].
#[cfg(feature = "instant-snapshots")]
#[async_trait::async_trait]
impl<T: super::InstantSnapshots> InstantSnapshots for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::instant_snapshots::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::instant_snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::instant_snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshot>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::instant_snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::instant_snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::instant_snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::instant_snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::instant_snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::instant_snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InterconnectAttachmentGroups].
#[cfg(feature = "interconnect-attachment-groups")]
#[async_trait::async_trait]
pub trait InterconnectAttachmentGroups: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::interconnect_attachment_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::interconnect_attachment_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentGroup>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::interconnect_attachment_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_operational_status(
        &self,
        req: crate::model::interconnect_attachment_groups::GetOperationalStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::InterconnectAttachmentGroupsGetOperationalStatusResponse,
        >,
    >;

    async fn insert(
        &self,
        req: crate::model::interconnect_attachment_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::interconnect_attachment_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InterconnectAttachmentGroupsListResponse>,
    >;

    async fn patch(
        &self,
        req: crate::model::interconnect_attachment_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::interconnect_attachment_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::interconnect_attachment_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InterconnectAttachmentGroups] also implement [InterconnectAttachmentGroups].
#[cfg(feature = "interconnect-attachment-groups")]
#[async_trait::async_trait]
impl<T: super::InterconnectAttachmentGroups> InterconnectAttachmentGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::interconnect_attachment_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnect_attachment_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::interconnect_attachment_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operational_status(
        &self,
        req: crate::model::interconnect_attachment_groups::GetOperationalStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::InterconnectAttachmentGroupsGetOperationalStatusResponse,
        >,
    > {
        T::get_operational_status(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::interconnect_attachment_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnect_attachment_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InterconnectAttachmentGroupsListResponse>,
    > {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::interconnect_attachment_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::interconnect_attachment_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::interconnect_attachment_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InterconnectAttachments].
#[cfg(feature = "interconnect-attachments")]
#[async_trait::async_trait]
pub trait InterconnectAttachments: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::interconnect_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::interconnect_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::interconnect_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachment>>;

    async fn insert(
        &self,
        req: crate::model::interconnect_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::interconnect_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentList>>;

    async fn patch(
        &self,
        req: crate::model::interconnect_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::interconnect_attachments::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InterconnectAttachments] also implement [InterconnectAttachments].
#[cfg(feature = "interconnect-attachments")]
#[async_trait::async_trait]
impl<T: super::InterconnectAttachments> InterconnectAttachments for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::interconnect_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentAggregatedList>>
    {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::interconnect_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnect_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachment>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::interconnect_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnect_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectAttachmentList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::interconnect_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::interconnect_attachments::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InterconnectGroups].
#[cfg(feature = "interconnect-groups")]
#[async_trait::async_trait]
pub trait InterconnectGroups: std::fmt::Debug + Send + Sync {
    async fn create_members(
        &self,
        req: crate::model::interconnect_groups::CreateMembersRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::interconnect_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::interconnect_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectGroup>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::interconnect_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_operational_status(
        &self,
        req: crate::model::interconnect_groups::GetOperationalStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InterconnectGroupsGetOperationalStatusResponse>,
    >;

    async fn insert(
        &self,
        req: crate::model::interconnect_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::interconnect_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectGroupsListResponse>>;

    async fn patch(
        &self,
        req: crate::model::interconnect_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::interconnect_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::interconnect_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::InterconnectGroups] also implement [InterconnectGroups].
#[cfg(feature = "interconnect-groups")]
#[async_trait::async_trait]
impl<T: super::InterconnectGroups> InterconnectGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create_members(
        &self,
        req: crate::model::interconnect_groups::CreateMembersRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::create_members(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::interconnect_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnect_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::interconnect_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operational_status(
        &self,
        req: crate::model::interconnect_groups::GetOperationalStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::InterconnectGroupsGetOperationalStatusResponse>,
    > {
        T::get_operational_status(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::interconnect_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnect_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectGroupsListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::interconnect_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::interconnect_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::interconnect_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::InterconnectLocations].
#[cfg(feature = "interconnect-locations")]
#[async_trait::async_trait]
pub trait InterconnectLocations: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::interconnect_locations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectLocation>>;

    async fn list(
        &self,
        req: crate::model::interconnect_locations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectLocationList>>;
}

/// All implementations of [super::InterconnectLocations] also implement [InterconnectLocations].
#[cfg(feature = "interconnect-locations")]
#[async_trait::async_trait]
impl<T: super::InterconnectLocations> InterconnectLocations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnect_locations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectLocation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnect_locations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectLocationList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::InterconnectRemoteLocations].
#[cfg(feature = "interconnect-remote-locations")]
#[async_trait::async_trait]
pub trait InterconnectRemoteLocations: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::interconnect_remote_locations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectRemoteLocation>>;

    async fn list(
        &self,
        req: crate::model::interconnect_remote_locations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectRemoteLocationList>>;
}

/// All implementations of [super::InterconnectRemoteLocations] also implement [InterconnectRemoteLocations].
#[cfg(feature = "interconnect-remote-locations")]
#[async_trait::async_trait]
impl<T: super::InterconnectRemoteLocations> InterconnectRemoteLocations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnect_remote_locations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectRemoteLocation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnect_remote_locations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectRemoteLocationList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Interconnects].
#[cfg(feature = "interconnects")]
#[async_trait::async_trait]
pub trait Interconnects: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::interconnects::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::interconnects::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Interconnect>>;

    async fn get_diagnostics(
        &self,
        req: crate::model::interconnects::GetDiagnosticsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectsGetDiagnosticsResponse>>;

    async fn get_macsec_config(
        &self,
        req: crate::model::interconnects::GetMacsecConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectsGetMacsecConfigResponse>>;

    async fn insert(
        &self,
        req: crate::model::interconnects::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::interconnects::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectList>>;

    async fn patch(
        &self,
        req: crate::model::interconnects::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::interconnects::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Interconnects] also implement [Interconnects].
#[cfg(feature = "interconnects")]
#[async_trait::async_trait]
impl<T: super::Interconnects> Interconnects for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::interconnects::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::interconnects::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Interconnect>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_diagnostics(
        &self,
        req: crate::model::interconnects::GetDiagnosticsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectsGetDiagnosticsResponse>>
    {
        T::get_diagnostics(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_macsec_config(
        &self,
        req: crate::model::interconnects::GetMacsecConfigRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectsGetMacsecConfigResponse>>
    {
        T::get_macsec_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::interconnects::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::interconnects::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InterconnectList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::interconnects::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::interconnects::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::LicenseCodes].
#[cfg(feature = "license-codes")]
#[async_trait::async_trait]
pub trait LicenseCodes: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::license_codes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::LicenseCode>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::license_codes::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;
}

/// All implementations of [super::LicenseCodes] also implement [LicenseCodes].
#[cfg(feature = "license-codes")]
#[async_trait::async_trait]
impl<T: super::LicenseCodes> LicenseCodes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::license_codes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::LicenseCode>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::license_codes::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Licenses].
#[cfg(feature = "licenses")]
#[async_trait::async_trait]
pub trait Licenses: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::licenses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::licenses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::License>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::licenses::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::licenses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::licenses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::LicensesListResponse>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::licenses::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::licenses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::licenses::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Licenses] also implement [Licenses].
#[cfg(feature = "licenses")]
#[async_trait::async_trait]
impl<T: super::Licenses> Licenses for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::licenses::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::licenses::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::License>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::licenses::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::licenses::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::licenses::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::LicensesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::licenses::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::licenses::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::licenses::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::MachineImages].
#[cfg(feature = "machine-images")]
#[async_trait::async_trait]
pub trait MachineImages: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::machine_images::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::machine_images::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineImage>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::machine_images::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::machine_images::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::machine_images::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineImageList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::machine_images::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::machine_images::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::machine_images::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::MachineImages] also implement [MachineImages].
#[cfg(feature = "machine-images")]
#[async_trait::async_trait]
impl<T: super::MachineImages> MachineImages for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::machine_images::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::machine_images::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineImage>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::machine_images::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::machine_images::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::machine_images::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineImageList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::machine_images::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::machine_images::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::machine_images::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::MachineTypes].
#[cfg(feature = "machine-types")]
#[async_trait::async_trait]
pub trait MachineTypes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::machine_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineTypeAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::machine_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineType>>;

    async fn list(
        &self,
        req: crate::model::machine_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineTypeList>>;
}

/// All implementations of [super::MachineTypes] also implement [MachineTypes].
#[cfg(feature = "machine-types")]
#[async_trait::async_trait]
impl<T: super::MachineTypes> MachineTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::machine_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineTypeAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::machine_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::machine_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::MachineTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::NetworkAttachments].
#[cfg(feature = "network-attachments")]
#[async_trait::async_trait]
pub trait NetworkAttachments: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::network_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachmentAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::network_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::network_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachment>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::network_attachments::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::network_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::network_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachmentList>>;

    async fn patch(
        &self,
        req: crate::model::network_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::network_attachments::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::network_attachments::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NetworkAttachments] also implement [NetworkAttachments].
#[cfg(feature = "network-attachments")]
#[async_trait::async_trait]
impl<T: super::NetworkAttachments> NetworkAttachments for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::network_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachmentAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::network_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::network_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachment>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::network_attachments::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::network_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::network_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkAttachmentList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::network_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::network_attachments::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::network_attachments::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NetworkEdgeSecurityServices].
#[cfg(feature = "network-edge-security-services")]
#[async_trait::async_trait]
pub trait NetworkEdgeSecurityServices: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::network_edge_security_services::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEdgeSecurityServiceAggregatedList>,
    >;

    async fn delete(
        &self,
        req: crate::model::network_edge_security_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::network_edge_security_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEdgeSecurityService>>;

    async fn insert(
        &self,
        req: crate::model::network_edge_security_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch(
        &self,
        req: crate::model::network_edge_security_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NetworkEdgeSecurityServices] also implement [NetworkEdgeSecurityServices].
#[cfg(feature = "network-edge-security-services")]
#[async_trait::async_trait]
impl<T: super::NetworkEdgeSecurityServices> NetworkEdgeSecurityServices for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::network_edge_security_services::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEdgeSecurityServiceAggregatedList>,
    > {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::network_edge_security_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::network_edge_security_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEdgeSecurityService>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::network_edge_security_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::network_edge_security_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NetworkEndpointGroups].
#[cfg(feature = "network-endpoint-groups")]
#[async_trait::async_trait]
pub trait NetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::network_endpoint_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupAggregatedList>>;

    async fn attach_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn detach_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>;

    async fn insert(
        &self,
        req: crate::model::network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>;

    async fn list_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    >;

    async fn test_iam_permissions(
        &self,
        req: crate::model::network_endpoint_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NetworkEndpointGroups] also implement [NetworkEndpointGroups].
#[cfg(feature = "network-endpoint-groups")]
#[async_trait::async_trait]
impl<T: super::NetworkEndpointGroups> NetworkEndpointGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::network_endpoint_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupAggregatedList>>
    {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn attach_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::attach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn detach_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::detach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_network_endpoints(
        &self,
        req: crate::model::network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    > {
        T::list_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::network_endpoint_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NetworkFirewallPolicies].
#[cfg(feature = "network-firewall-policies")]
#[async_trait::async_trait]
pub trait NetworkFirewallPolicies: std::fmt::Debug + Send + Sync {
    async fn add_association(
        &self,
        req: crate::model::network_firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::AddPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_rule(
        &self,
        req: crate::model::network_firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::network_firewall_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkFirewallPolicyAggregatedList>>;

    async fn clone_rules(
        &self,
        req: crate::model::network_firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::network_firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::network_firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>>;

    async fn get_association(
        &self,
        req: crate::model::network_firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::network_firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::GetPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>;

    async fn get_rule(
        &self,
        req: crate::model::network_firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::network_firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::network_firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>;

    async fn patch(
        &self,
        req: crate::model::network_firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::PatchPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::network_firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_association(
        &self,
        req: crate::model::network_firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::RemovePacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::network_firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::network_firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::network_firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NetworkFirewallPolicies] also implement [NetworkFirewallPolicies].
#[cfg(feature = "network-firewall-policies")]
#[async_trait::async_trait]
impl<T: super::NetworkFirewallPolicies> NetworkFirewallPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_association(
        &self,
        req: crate::model::network_firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::AddPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_packet_mirroring_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::network_firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::network_firewall_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkFirewallPolicyAggregatedList>>
    {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn clone_rules(
        &self,
        req: crate::model::network_firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::clone_rules(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::network_firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::network_firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_association(
        &self,
        req: crate::model::network_firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>> {
        T::get_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::network_firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::GetPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>> {
        T::get_packet_mirroring_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::network_firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::network_firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::network_firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::network_firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::PatchPacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_packet_mirroring_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::network_firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_association(
        &self,
        req: crate::model::network_firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_packet_mirroring_rule(
        &self,
        req: crate::model::network_firewall_policies::RemovePacketMirroringRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_packet_mirroring_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::network_firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::network_firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::network_firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NetworkProfiles].
#[cfg(feature = "network-profiles")]
#[async_trait::async_trait]
pub trait NetworkProfiles: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::network_profiles::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkProfile>>;

    async fn list(
        &self,
        req: crate::model::network_profiles::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkProfilesListResponse>>;
}

/// All implementations of [super::NetworkProfiles] also implement [NetworkProfiles].
#[cfg(feature = "network-profiles")]
#[async_trait::async_trait]
impl<T: super::NetworkProfiles> NetworkProfiles for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::network_profiles::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkProfile>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::network_profiles::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkProfilesListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Networks].
#[cfg(feature = "networks")]
#[async_trait::async_trait]
pub trait Networks: std::fmt::Debug + Send + Sync {
    async fn add_peering(
        &self,
        req: crate::model::networks::AddPeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::networks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::networks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Network>>;

    async fn get_effective_firewalls(
        &self,
        req: crate::model::networks::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworksGetEffectiveFirewallsResponse>>;

    async fn insert(
        &self,
        req: crate::model::networks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::networks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkList>>;

    async fn list_peering_routes(
        &self,
        req: crate::model::networks::ListPeeringRoutesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExchangedPeeringRoutesList>>;

    async fn patch(
        &self,
        req: crate::model::networks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_peering(
        &self,
        req: crate::model::networks::RemovePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn request_remove_peering(
        &self,
        req: crate::model::networks::RequestRemovePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn switch_to_custom_mode(
        &self,
        req: crate::model::networks::SwitchToCustomModeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_peering(
        &self,
        req: crate::model::networks::UpdatePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Networks] also implement [Networks].
#[cfg(feature = "networks")]
#[async_trait::async_trait]
impl<T: super::Networks> Networks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_peering(
        &self,
        req: crate::model::networks::AddPeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_peering(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::networks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::networks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Network>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_effective_firewalls(
        &self,
        req: crate::model::networks::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworksGetEffectiveFirewallsResponse>>
    {
        T::get_effective_firewalls(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::networks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::networks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_peering_routes(
        &self,
        req: crate::model::networks::ListPeeringRoutesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ExchangedPeeringRoutesList>> {
        T::list_peering_routes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::networks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_peering(
        &self,
        req: crate::model::networks::RemovePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_peering(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn request_remove_peering(
        &self,
        req: crate::model::networks::RequestRemovePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::request_remove_peering(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn switch_to_custom_mode(
        &self,
        req: crate::model::networks::SwitchToCustomModeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::switch_to_custom_mode(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_peering(
        &self,
        req: crate::model::networks::UpdatePeeringRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_peering(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NodeGroups].
#[cfg(feature = "node-groups")]
#[async_trait::async_trait]
pub trait NodeGroups: std::fmt::Debug + Send + Sync {
    async fn add_nodes(
        &self,
        req: crate::model::node_groups::AddNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::node_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::node_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_nodes(
        &self,
        req: crate::model::node_groups::DeleteNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::node_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroup>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::node_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::node_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::node_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupList>>;

    async fn list_nodes(
        &self,
        req: crate::model::node_groups::ListNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupsListNodes>>;

    async fn patch(
        &self,
        req: crate::model::node_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn perform_maintenance(
        &self,
        req: crate::model::node_groups::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::node_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_node_template(
        &self,
        req: crate::model::node_groups::SetNodeTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn simulate_maintenance_event(
        &self,
        req: crate::model::node_groups::SimulateMaintenanceEventRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::node_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NodeGroups] also implement [NodeGroups].
#[cfg(feature = "node-groups")]
#[async_trait::async_trait]
impl<T: super::NodeGroups> NodeGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_nodes(
        &self,
        req: crate::model::node_groups::AddNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_nodes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::node_groups::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::node_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_nodes(
        &self,
        req: crate::model::node_groups::DeleteNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_nodes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::node_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::node_groups::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::node_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::node_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_nodes(
        &self,
        req: crate::model::node_groups::ListNodesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeGroupsListNodes>> {
        T::list_nodes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::node_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_maintenance(
        &self,
        req: crate::model::node_groups::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::perform_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::node_groups::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_node_template(
        &self,
        req: crate::model::node_groups::SetNodeTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_node_template(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn simulate_maintenance_event(
        &self,
        req: crate::model::node_groups::SimulateMaintenanceEventRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::simulate_maintenance_event(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::node_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NodeTemplates].
#[cfg(feature = "node-templates")]
#[async_trait::async_trait]
pub trait NodeTemplates: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::node_templates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplateAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::node_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::node_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplate>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::node_templates::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::node_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::node_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplateList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::node_templates::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::node_templates::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::NodeTemplates] also implement [NodeTemplates].
#[cfg(feature = "node-templates")]
#[async_trait::async_trait]
impl<T: super::NodeTemplates> NodeTemplates for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::node_templates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplateAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::node_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::node_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplate>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::node_templates::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::node_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::node_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTemplateList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::node_templates::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::node_templates::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::NodeTypes].
#[cfg(feature = "node-types")]
#[async_trait::async_trait]
pub trait NodeTypes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::node_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTypeAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::node_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeType>>;

    async fn list(
        &self,
        req: crate::model::node_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTypeList>>;
}

/// All implementations of [super::NodeTypes] also implement [NodeTypes].
#[cfg(feature = "node-types")]
#[async_trait::async_trait]
impl<T: super::NodeTypes> NodeTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::node_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTypeAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::node_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::node_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NodeTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::OrganizationSecurityPolicies].
#[cfg(feature = "organization-security-policies")]
#[async_trait::async_trait]
pub trait OrganizationSecurityPolicies: std::fmt::Debug + Send + Sync {
    async fn add_association(
        &self,
        req: crate::model::organization_security_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_rule(
        &self,
        req: crate::model::organization_security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn copy_rules(
        &self,
        req: crate::model::organization_security_policies::CopyRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::organization_security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::organization_security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>>;

    async fn get_association(
        &self,
        req: crate::model::organization_security_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyAssociation>>;

    async fn get_rule(
        &self,
        req: crate::model::organization_security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::organization_security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::organization_security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>;

    async fn list_associations(
        &self,
        req: crate::model::organization_security_policies::ListAssociationsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::OrganizationSecurityPoliciesListAssociationsResponse>,
    >;

    async fn list_preconfigured_expression_sets(
        &self,
        req: crate::model::organization_security_policies::ListPreconfiguredExpressionSetsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
        >,
    >;

    async fn r#move(
        &self,
        req: crate::model::organization_security_policies::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch(
        &self,
        req: crate::model::organization_security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::organization_security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_association(
        &self,
        req: crate::model::organization_security_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::organization_security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::OrganizationSecurityPolicies] also implement [OrganizationSecurityPolicies].
#[cfg(feature = "organization-security-policies")]
#[async_trait::async_trait]
impl<T: super::OrganizationSecurityPolicies> OrganizationSecurityPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_association(
        &self,
        req: crate::model::organization_security_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::organization_security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn copy_rules(
        &self,
        req: crate::model::organization_security_policies::CopyRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::copy_rules(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::organization_security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::organization_security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_association(
        &self,
        req: crate::model::organization_security_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyAssociation>> {
        T::get_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::organization_security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::organization_security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::organization_security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_associations(
        &self,
        req: crate::model::organization_security_policies::ListAssociationsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::OrganizationSecurityPoliciesListAssociationsResponse>,
    > {
        T::list_associations(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_preconfigured_expression_sets(
        &self,
        req: crate::model::organization_security_policies::ListPreconfiguredExpressionSetsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
        >,
    > {
        T::list_preconfigured_expression_sets(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn r#move(
        &self,
        req: crate::model::organization_security_policies::MoveRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::r#move(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::organization_security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::organization_security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_association(
        &self,
        req: crate::model::organization_security_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::organization_security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_organization_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::PacketMirrorings].
#[cfg(feature = "packet-mirrorings")]
#[async_trait::async_trait]
pub trait PacketMirrorings: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::packet_mirrorings::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroringAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::packet_mirrorings::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::packet_mirrorings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroring>>;

    async fn insert(
        &self,
        req: crate::model::packet_mirrorings::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::packet_mirrorings::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroringList>>;

    async fn patch(
        &self,
        req: crate::model::packet_mirrorings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::packet_mirrorings::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::PacketMirrorings] also implement [PacketMirrorings].
#[cfg(feature = "packet-mirrorings")]
#[async_trait::async_trait]
impl<T: super::PacketMirrorings> PacketMirrorings for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::packet_mirrorings::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroringAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::packet_mirrorings::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::packet_mirrorings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroring>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::packet_mirrorings::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::packet_mirrorings::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PacketMirroringList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::packet_mirrorings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::packet_mirrorings::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::PreviewFeatures].
#[cfg(feature = "preview-features")]
#[async_trait::async_trait]
pub trait PreviewFeatures: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::preview_features::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PreviewFeature>>;

    async fn list(
        &self,
        req: crate::model::preview_features::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PreviewFeatureList>>;

    async fn update(
        &self,
        req: crate::model::preview_features::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::PreviewFeatures] also implement [PreviewFeatures].
#[cfg(feature = "preview-features")]
#[async_trait::async_trait]
impl<T: super::PreviewFeatures> PreviewFeatures for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::preview_features::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PreviewFeature>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::preview_features::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PreviewFeatureList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::preview_features::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Projects].
#[cfg(feature = "projects")]
#[async_trait::async_trait]
pub trait Projects: std::fmt::Debug + Send + Sync {
    async fn disable_xpn_host(
        &self,
        req: crate::model::projects::DisableXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn disable_xpn_resource(
        &self,
        req: crate::model::projects::DisableXpnResourceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn enable_xpn_host(
        &self,
        req: crate::model::projects::EnableXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn enable_xpn_resource(
        &self,
        req: crate::model::projects::EnableXpnResourceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::projects::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Project>>;

    async fn get_xpn_host(
        &self,
        req: crate::model::projects::GetXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Project>>;

    async fn get_xpn_resources(
        &self,
        req: crate::model::projects::GetXpnResourcesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ProjectsGetXpnResources>>;

    async fn list_xpn_hosts(
        &self,
        req: crate::model::projects::ListXpnHostsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::XpnHostList>>;

    async fn move_disk(
        &self,
        req: crate::model::projects::MoveDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn move_instance(
        &self,
        req: crate::model::projects::MoveInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_cloud_armor_tier(
        &self,
        req: crate::model::projects::SetCloudArmorTierRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_common_instance_metadata(
        &self,
        req: crate::model::projects::SetCommonInstanceMetadataRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_default_network_tier(
        &self,
        req: crate::model::projects::SetDefaultNetworkTierRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_usage_export_bucket(
        &self,
        req: crate::model::projects::SetUsageExportBucketRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Projects] also implement [Projects].
#[cfg(feature = "projects")]
#[async_trait::async_trait]
impl<T: super::Projects> Projects for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn disable_xpn_host(
        &self,
        req: crate::model::projects::DisableXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::disable_xpn_host(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn disable_xpn_resource(
        &self,
        req: crate::model::projects::DisableXpnResourceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::disable_xpn_resource(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn enable_xpn_host(
        &self,
        req: crate::model::projects::EnableXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::enable_xpn_host(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn enable_xpn_resource(
        &self,
        req: crate::model::projects::EnableXpnResourceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::enable_xpn_resource(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::projects::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Project>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_xpn_host(
        &self,
        req: crate::model::projects::GetXpnHostRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Project>> {
        T::get_xpn_host(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_xpn_resources(
        &self,
        req: crate::model::projects::GetXpnResourcesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ProjectsGetXpnResources>> {
        T::get_xpn_resources(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_xpn_hosts(
        &self,
        req: crate::model::projects::ListXpnHostsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::XpnHostList>> {
        T::list_xpn_hosts(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn move_disk(
        &self,
        req: crate::model::projects::MoveDiskRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::move_disk(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn move_instance(
        &self,
        req: crate::model::projects::MoveInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::move_instance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_cloud_armor_tier(
        &self,
        req: crate::model::projects::SetCloudArmorTierRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_cloud_armor_tier(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_common_instance_metadata(
        &self,
        req: crate::model::projects::SetCommonInstanceMetadataRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_common_instance_metadata(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_default_network_tier(
        &self,
        req: crate::model::projects::SetDefaultNetworkTierRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_default_network_tier(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_usage_export_bucket(
        &self,
        req: crate::model::projects::SetUsageExportBucketRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_usage_export_bucket(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::PublicAdvertisedPrefixes].
#[cfg(feature = "public-advertised-prefixes")]
#[async_trait::async_trait]
pub trait PublicAdvertisedPrefixes: std::fmt::Debug + Send + Sync {
    async fn announce(
        &self,
        req: crate::model::public_advertised_prefixes::AnnounceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::public_advertised_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::public_advertised_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefix>>;

    async fn insert(
        &self,
        req: crate::model::public_advertised_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::public_advertised_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefixList>>;

    async fn patch(
        &self,
        req: crate::model::public_advertised_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn withdraw(
        &self,
        req: crate::model::public_advertised_prefixes::WithdrawRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::PublicAdvertisedPrefixes] also implement [PublicAdvertisedPrefixes].
#[cfg(feature = "public-advertised-prefixes")]
#[async_trait::async_trait]
impl<T: super::PublicAdvertisedPrefixes> PublicAdvertisedPrefixes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn announce(
        &self,
        req: crate::model::public_advertised_prefixes::AnnounceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::announce(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::public_advertised_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::public_advertised_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefix>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::public_advertised_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::public_advertised_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefixList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::public_advertised_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn withdraw(
        &self,
        req: crate::model::public_advertised_prefixes::WithdrawRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::withdraw(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::PublicDelegatedPrefixes].
#[cfg(feature = "public-delegated-prefixes")]
#[async_trait::async_trait]
pub trait PublicDelegatedPrefixes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::public_delegated_prefixes::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixAggregatedList>>;

    async fn announce(
        &self,
        req: crate::model::public_delegated_prefixes::AnnounceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::public_delegated_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::public_delegated_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>>;

    async fn insert(
        &self,
        req: crate::model::public_delegated_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::public_delegated_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>>;

    async fn patch(
        &self,
        req: crate::model::public_delegated_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn withdraw(
        &self,
        req: crate::model::public_delegated_prefixes::WithdrawRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::PublicDelegatedPrefixes] also implement [PublicDelegatedPrefixes].
#[cfg(feature = "public-delegated-prefixes")]
#[async_trait::async_trait]
impl<T: super::PublicDelegatedPrefixes> PublicDelegatedPrefixes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::public_delegated_prefixes::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixAggregatedList>>
    {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn announce(
        &self,
        req: crate::model::public_delegated_prefixes::AnnounceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::announce(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::public_delegated_prefixes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::public_delegated_prefixes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::public_delegated_prefixes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::public_delegated_prefixes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::public_delegated_prefixes::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn withdraw(
        &self,
        req: crate::model::public_delegated_prefixes::WithdrawRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::withdraw(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionAutoscalers].
#[cfg(feature = "region-autoscalers")]
#[async_trait::async_trait]
pub trait RegionAutoscalers: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_autoscalers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_autoscalers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Autoscaler>>;

    async fn insert(
        &self,
        req: crate::model::region_autoscalers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_autoscalers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionAutoscalerList>>;

    async fn patch(
        &self,
        req: crate::model::region_autoscalers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::region_autoscalers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionAutoscalers] also implement [RegionAutoscalers].
#[cfg(feature = "region-autoscalers")]
#[async_trait::async_trait]
impl<T: super::RegionAutoscalers> RegionAutoscalers for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_autoscalers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_autoscalers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Autoscaler>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_autoscalers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_autoscalers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionAutoscalerList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_autoscalers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_autoscalers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionBackendServices].
#[cfg(feature = "region-backend-services")]
#[async_trait::async_trait]
pub trait RegionBackendServices: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_backend_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_backend_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendService>>;

    async fn get_health(
        &self,
        req: crate::model::region_backend_services::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::region_backend_services::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::region_backend_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_backend_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceList>>;

    async fn list_usable(
        &self,
        req: crate::model::region_backend_services::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>>;

    async fn patch(
        &self,
        req: crate::model::region_backend_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::region_backend_services::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_security_policy(
        &self,
        req: crate::model::region_backend_services::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::region_backend_services::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::region_backend_services::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionBackendServices] also implement [RegionBackendServices].
#[cfg(feature = "region-backend-services")]
#[async_trait::async_trait]
impl<T: super::RegionBackendServices> RegionBackendServices for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_backend_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_backend_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendService>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_health(
        &self,
        req: crate::model::region_backend_services::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>> {
        T::get_health(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::region_backend_services::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_backend_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_backend_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_usable(
        &self,
        req: crate::model::region_backend_services::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>> {
        T::list_usable(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_backend_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::region_backend_services::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_security_policy(
        &self,
        req: crate::model::region_backend_services::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::region_backend_services::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_backend_services::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionCommitments].
#[cfg(feature = "region-commitments")]
#[async_trait::async_trait]
pub trait RegionCommitments: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::region_commitments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CommitmentAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::region_commitments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Commitment>>;

    async fn insert(
        &self,
        req: crate::model::region_commitments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_commitments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CommitmentList>>;

    async fn update(
        &self,
        req: crate::model::region_commitments::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionCommitments] also implement [RegionCommitments].
#[cfg(feature = "region-commitments")]
#[async_trait::async_trait]
impl<T: super::RegionCommitments> RegionCommitments for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::region_commitments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CommitmentAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_commitments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Commitment>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_commitments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_commitments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::CommitmentList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_commitments::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionDiskTypes].
#[cfg(feature = "region-disk-types")]
#[async_trait::async_trait]
pub trait RegionDiskTypes: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::region_disk_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskType>>;

    async fn list(
        &self,
        req: crate::model::region_disk_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionDiskTypeList>>;
}

/// All implementations of [super::RegionDiskTypes] also implement [RegionDiskTypes].
#[cfg(feature = "region-disk-types")]
#[async_trait::async_trait]
impl<T: super::RegionDiskTypes> RegionDiskTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_disk_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_disk_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionDiskTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::RegionDisks].
#[cfg(feature = "region-disks")]
#[async_trait::async_trait]
pub trait RegionDisks: std::fmt::Debug + Send + Sync {
    async fn add_resource_policies(
        &self,
        req: crate::model::region_disks::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn bulk_insert(
        &self,
        req: crate::model::region_disks::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn create_snapshot(
        &self,
        req: crate::model::region_disks::CreateSnapshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::region_disks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_disks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Disk>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::region_disks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::region_disks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_disks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskList>>;

    async fn remove_resource_policies(
        &self,
        req: crate::model::region_disks::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resize(
        &self,
        req: crate::model::region_disks::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::region_disks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::region_disks::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start_async_replication(
        &self,
        req: crate::model::region_disks::StartAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_async_replication(
        &self,
        req: crate::model::region_disks::StopAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_group_async_replication(
        &self,
        req: crate::model::region_disks::StopGroupAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::region_disks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::region_disks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionDisks] also implement [RegionDisks].
#[cfg(feature = "region-disks")]
#[async_trait::async_trait]
impl<T: super::RegionDisks> RegionDisks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_resource_policies(
        &self,
        req: crate::model::region_disks::AddResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn bulk_insert(
        &self,
        req: crate::model::region_disks::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::bulk_insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn create_snapshot(
        &self,
        req: crate::model::region_disks::CreateSnapshotRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::create_snapshot(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_disks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_disks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Disk>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::region_disks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_disks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_disks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::DiskList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_resource_policies(
        &self,
        req: crate::model::region_disks::RemoveResourcePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_resource_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resize(
        &self,
        req: crate::model::region_disks::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resize(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::region_disks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::region_disks::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_async_replication(
        &self,
        req: crate::model::region_disks::StartAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_async_replication(
        &self,
        req: crate::model::region_disks::StopAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_group_async_replication(
        &self,
        req: crate::model::region_disks::StopGroupAsyncReplicationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_group_async_replication(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::region_disks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_disks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionHealthCheckServices].
#[cfg(feature = "region-health-check-services")]
#[async_trait::async_trait]
pub trait RegionHealthCheckServices: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_health_check_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_health_check_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckService>>;

    async fn insert(
        &self,
        req: crate::model::region_health_check_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_health_check_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckServicesList>>;

    async fn patch(
        &self,
        req: crate::model::region_health_check_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionHealthCheckServices] also implement [RegionHealthCheckServices].
#[cfg(feature = "region-health-check-services")]
#[async_trait::async_trait]
impl<T: super::RegionHealthCheckServices> RegionHealthCheckServices for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_health_check_services::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_health_check_services::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckService>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_health_check_services::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_health_check_services::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckServicesList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_health_check_services::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionHealthChecks].
#[cfg(feature = "region-health-checks")]
#[async_trait::async_trait]
pub trait RegionHealthChecks: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheck>>;

    async fn insert(
        &self,
        req: crate::model::region_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckList>>;

    async fn patch(
        &self,
        req: crate::model::region_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::region_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionHealthChecks] also implement [RegionHealthChecks].
#[cfg(feature = "region-health-checks")]
#[async_trait::async_trait]
impl<T: super::RegionHealthChecks> RegionHealthChecks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_health_checks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_health_checks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheck>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_health_checks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_health_checks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::HealthCheckList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_health_checks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_health_checks::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionInstanceGroupManagers].
#[cfg(feature = "region-instance-group-managers")]
#[async_trait::async_trait]
pub trait RegionInstanceGroupManagers: std::fmt::Debug + Send + Sync {
    async fn abandon_instances(
        &self,
        req: crate::model::region_instance_group_managers::AbandonInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn apply_updates_to_instances(
        &self,
        req: crate::model::region_instance_group_managers::ApplyUpdatesToInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn create_instances(
        &self,
        req: crate::model::region_instance_group_managers::CreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::region_instance_group_managers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_instances(
        &self,
        req: crate::model::region_instance_group_managers::DeleteInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::DeletePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_instance_group_managers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManager>>;

    async fn insert(
        &self,
        req: crate::model::region_instance_group_managers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_instance_group_managers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupManagerList>>;

    async fn list_errors(
        &self,
        req: crate::model::region_instance_group_managers::ListErrorsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListErrorsResponse>,
    >;

    async fn list_managed_instances(
        &self,
        req: crate::model::region_instance_group_managers::ListManagedInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListInstancesResponse>,
    >;

    async fn list_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::ListPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListInstanceConfigsResp>,
    >;

    async fn patch(
        &self,
        req: crate::model::region_instance_group_managers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::PatchPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn recreate_instances(
        &self,
        req: crate::model::region_instance_group_managers::RecreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resize(
        &self,
        req: crate::model::region_instance_group_managers::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resume_instances(
        &self,
        req: crate::model::region_instance_group_managers::ResumeInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_instance_template(
        &self,
        req: crate::model::region_instance_group_managers::SetInstanceTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_target_pools(
        &self,
        req: crate::model::region_instance_group_managers::SetTargetPoolsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn start_instances(
        &self,
        req: crate::model::region_instance_group_managers::StartInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn stop_instances(
        &self,
        req: crate::model::region_instance_group_managers::StopInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn suspend_instances(
        &self,
        req: crate::model::region_instance_group_managers::SuspendInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::UpdatePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionInstanceGroupManagers] also implement [RegionInstanceGroupManagers].
#[cfg(feature = "region-instance-group-managers")]
#[async_trait::async_trait]
impl<T: super::RegionInstanceGroupManagers> RegionInstanceGroupManagers for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn abandon_instances(
        &self,
        req: crate::model::region_instance_group_managers::AbandonInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::abandon_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn apply_updates_to_instances(
        &self,
        req: crate::model::region_instance_group_managers::ApplyUpdatesToInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::apply_updates_to_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn create_instances(
        &self,
        req: crate::model::region_instance_group_managers::CreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::create_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_instance_group_managers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_instances(
        &self,
        req: crate::model::region_instance_group_managers::DeleteInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::DeletePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_instance_group_managers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroupManager>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_instance_group_managers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_instance_group_managers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupManagerList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_errors(
        &self,
        req: crate::model::region_instance_group_managers::ListErrorsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListErrorsResponse>,
    > {
        T::list_errors(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_managed_instances(
        &self,
        req: crate::model::region_instance_group_managers::ListManagedInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListInstancesResponse>,
    > {
        T::list_managed_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::ListPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::RegionInstanceGroupManagersListInstanceConfigsResp>,
    > {
        T::list_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_instance_group_managers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::PatchPerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn recreate_instances(
        &self,
        req: crate::model::region_instance_group_managers::RecreateInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::recreate_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resize(
        &self,
        req: crate::model::region_instance_group_managers::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resize(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resume_instances(
        &self,
        req: crate::model::region_instance_group_managers::ResumeInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resume_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_instance_template(
        &self,
        req: crate::model::region_instance_group_managers::SetInstanceTemplateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_instance_template(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_target_pools(
        &self,
        req: crate::model::region_instance_group_managers::SetTargetPoolsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_target_pools(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_instances(
        &self,
        req: crate::model::region_instance_group_managers::StartInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::start_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_instances(
        &self,
        req: crate::model::region_instance_group_managers::StopInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::stop_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn suspend_instances(
        &self,
        req: crate::model::region_instance_group_managers::SuspendInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::suspend_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_per_instance_configs(
        &self,
        req: crate::model::region_instance_group_managers::UpdatePerInstanceConfigsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_per_instance_configs(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionInstanceGroups].
#[cfg(feature = "region-instance-groups")]
#[async_trait::async_trait]
pub trait RegionInstanceGroups: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::region_instance_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroup>>;

    async fn list(
        &self,
        req: crate::model::region_instance_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupList>>;

    async fn list_instances(
        &self,
        req: crate::model::region_instance_groups::ListInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupsListInstances>>;

    async fn set_named_ports(
        &self,
        req: crate::model::region_instance_groups::SetNamedPortsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::region_instance_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionInstanceGroups] also implement [RegionInstanceGroups].
#[cfg(feature = "region-instance-groups")]
#[async_trait::async_trait]
impl<T: super::RegionInstanceGroups> RegionInstanceGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_instance_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_instance_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_instances(
        &self,
        req: crate::model::region_instance_groups::ListInstancesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionInstanceGroupsListInstances>>
    {
        T::list_instances(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_named_ports(
        &self,
        req: crate::model::region_instance_groups::SetNamedPortsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_named_ports(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::region_instance_groups::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionInstanceTemplates].
#[cfg(feature = "region-instance-templates")]
#[async_trait::async_trait]
pub trait RegionInstanceTemplates: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_instance_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_instance_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplate>>;

    async fn insert(
        &self,
        req: crate::model::region_instance_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_instance_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateList>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionInstanceTemplates] also implement [RegionInstanceTemplates].
#[cfg(feature = "region-instance-templates")]
#[async_trait::async_trait]
impl<T: super::RegionInstanceTemplates> RegionInstanceTemplates for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_instance_templates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_instance_templates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplate>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_instance_templates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_instance_templates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstanceTemplateList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionInstances].
#[cfg(feature = "region-instances")]
#[async_trait::async_trait]
pub trait RegionInstances: std::fmt::Debug + Send + Sync {
    async fn bulk_insert(
        &self,
        req: crate::model::region_instances::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionInstances] also implement [RegionInstances].
#[cfg(feature = "region-instances")]
#[async_trait::async_trait]
impl<T: super::RegionInstances> RegionInstances for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn bulk_insert(
        &self,
        req: crate::model::region_instances::BulkInsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::bulk_insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionInstantSnapshots].
#[cfg(feature = "region-instant-snapshots")]
#[async_trait::async_trait]
pub trait RegionInstantSnapshots: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_instant_snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_instant_snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshot>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::region_instant_snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::region_instant_snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_instant_snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::region_instant_snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::region_instant_snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::region_instant_snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionInstantSnapshots] also implement [RegionInstantSnapshots].
#[cfg(feature = "region-instant-snapshots")]
#[async_trait::async_trait]
impl<T: super::RegionInstantSnapshots> RegionInstantSnapshots for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_instant_snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_instant_snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshot>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::region_instant_snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_instant_snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_instant_snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::InstantSnapshotList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::region_instant_snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::region_instant_snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::region_instant_snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionNetworkEndpointGroups].
#[cfg(feature = "region-network-endpoint-groups")]
#[async_trait::async_trait]
pub trait RegionNetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    async fn attach_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::region_network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn detach_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>;

    async fn insert(
        &self,
        req: crate::model::region_network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>;

    async fn list_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    >;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionNetworkEndpointGroups] also implement [RegionNetworkEndpointGroups].
#[cfg(feature = "region-network-endpoint-groups")]
#[async_trait::async_trait]
impl<T: super::RegionNetworkEndpointGroups> RegionNetworkEndpointGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn attach_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::AttachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::attach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_network_endpoint_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn detach_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::DetachNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::detach_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_network_endpoint_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_network_endpoint_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_network_endpoint_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_network_endpoints(
        &self,
        req: crate::model::region_network_endpoint_groups::ListNetworkEndpointsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
    > {
        T::list_network_endpoints(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionNetworkFirewallPolicies].
#[cfg(feature = "region-network-firewall-policies")]
#[async_trait::async_trait]
pub trait RegionNetworkFirewallPolicies: std::fmt::Debug + Send + Sync {
    async fn add_association(
        &self,
        req: crate::model::region_network_firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_rule(
        &self,
        req: crate::model::region_network_firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn clone_rules(
        &self,
        req: crate::model::region_network_firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::region_network_firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_network_firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>>;

    async fn get_association(
        &self,
        req: crate::model::region_network_firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>;

    async fn get_effective_firewalls(
        &self,
        req: crate::model::region_network_firewall_policies::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse,
        >,
    >;

    async fn get_iam_policy(
        &self,
        req: crate::model::region_network_firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn get_rule(
        &self,
        req: crate::model::region_network_firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::region_network_firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_network_firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>;

    async fn patch(
        &self,
        req: crate::model::region_network_firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::region_network_firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_association(
        &self,
        req: crate::model::region_network_firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::region_network_firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::region_network_firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::region_network_firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionNetworkFirewallPolicies] also implement [RegionNetworkFirewallPolicies].
#[cfg(feature = "region-network-firewall-policies")]
#[async_trait::async_trait]
impl<T: super::RegionNetworkFirewallPolicies> RegionNetworkFirewallPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_association(
        &self,
        req: crate::model::region_network_firewall_policies::AddAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::region_network_firewall_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn clone_rules(
        &self,
        req: crate::model::region_network_firewall_policies::CloneRulesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::clone_rules(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_network_firewall_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_network_firewall_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_association(
        &self,
        req: crate::model::region_network_firewall_policies::GetAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>> {
        T::get_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_effective_firewalls(
        &self,
        req: crate::model::region_network_firewall_policies::GetEffectiveFirewallsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse,
        >,
    > {
        T::get_effective_firewalls(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::region_network_firewall_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::region_network_firewall_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_network_firewall_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_network_firewall_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::FirewallPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_network_firewall_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::region_network_firewall_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_association(
        &self,
        req: crate::model::region_network_firewall_policies::RemoveAssociationRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_association(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::region_network_firewall_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::region_network_firewall_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::region_network_firewall_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionNotificationEndpoints].
#[cfg(feature = "region-notification-endpoints")]
#[async_trait::async_trait]
pub trait RegionNotificationEndpoints: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_notification_endpoints::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_notification_endpoints::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NotificationEndpoint>>;

    async fn insert(
        &self,
        req: crate::model::region_notification_endpoints::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_notification_endpoints::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NotificationEndpointList>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionNotificationEndpoints] also implement [RegionNotificationEndpoints].
#[cfg(feature = "region-notification-endpoints")]
#[async_trait::async_trait]
impl<T: super::RegionNotificationEndpoints> RegionNotificationEndpoints for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_notification_endpoints::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_notification_endpoints::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NotificationEndpoint>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_notification_endpoints::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_notification_endpoints::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NotificationEndpointList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionOperations].
#[cfg(feature = "region-operations")]
#[async_trait::async_trait]
pub trait RegionOperations: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn get(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>>;

    async fn wait(
        &self,
        req: crate::model::region_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;
}

/// All implementations of [super::RegionOperations] also implement [RegionOperations].
#[cfg(feature = "region-operations")]
#[async_trait::async_trait]
impl<T: super::RegionOperations> RegionOperations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn wait(
        &self,
        req: crate::model::region_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::wait(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::RegionSecurityPolicies].
#[cfg(feature = "region-security-policies")]
#[async_trait::async_trait]
pub trait RegionSecurityPolicies: std::fmt::Debug + Send + Sync {
    async fn add_rule(
        &self,
        req: crate::model::region_security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::region_security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>>;

    async fn get_rule(
        &self,
        req: crate::model::region_security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::region_security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>;

    async fn patch(
        &self,
        req: crate::model::region_security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::region_security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::region_security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::region_security_policies::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionSecurityPolicies] also implement [RegionSecurityPolicies].
#[cfg(feature = "region-security-policies")]
#[async_trait::async_trait]
impl<T: super::RegionSecurityPolicies> RegionSecurityPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::region_security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::region_security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::region_security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::region_security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::region_security_policies::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionSslCertificates].
#[cfg(feature = "region-ssl-certificates")]
#[async_trait::async_trait]
pub trait RegionSslCertificates: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_ssl_certificates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_ssl_certificates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificate>>;

    async fn insert(
        &self,
        req: crate::model::region_ssl_certificates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_ssl_certificates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateList>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionSslCertificates] also implement [RegionSslCertificates].
#[cfg(feature = "region-ssl-certificates")]
#[async_trait::async_trait]
impl<T: super::RegionSslCertificates> RegionSslCertificates for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_ssl_certificates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_ssl_certificates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificate>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_ssl_certificates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_ssl_certificates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionSslPolicies].
#[cfg(feature = "region-ssl-policies")]
#[async_trait::async_trait]
pub trait RegionSslPolicies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_ssl_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_ssl_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPolicy>>;

    async fn insert(
        &self,
        req: crate::model::region_ssl_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_ssl_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesList>>;

    async fn list_available_features(
        &self,
        req: crate::model::region_ssl_policies::ListAvailableFeaturesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
    >;

    async fn patch(
        &self,
        req: crate::model::region_ssl_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionSslPolicies] also implement [RegionSslPolicies].
#[cfg(feature = "region-ssl-policies")]
#[async_trait::async_trait]
impl<T: super::RegionSslPolicies> RegionSslPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_ssl_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_ssl_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_ssl_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_ssl_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_available_features(
        &self,
        req: crate::model::region_ssl_policies::ListAvailableFeaturesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
    > {
        T::list_available_features(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_ssl_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionTargetHttpProxies].
#[cfg(feature = "region-target-http-proxies")]
#[async_trait::async_trait]
pub trait RegionTargetHttpProxies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_target_http_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_target_http_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxy>>;

    async fn insert(
        &self,
        req: crate::model::region_target_http_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_target_http_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>>;

    async fn set_url_map(
        &self,
        req: crate::model::region_target_http_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionTargetHttpProxies] also implement [RegionTargetHttpProxies].
#[cfg(feature = "region-target-http-proxies")]
#[async_trait::async_trait]
impl<T: super::RegionTargetHttpProxies> RegionTargetHttpProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_target_http_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_target_http_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_target_http_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_target_http_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_url_map(
        &self,
        req: crate::model::region_target_http_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_url_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionTargetHttpsProxies].
#[cfg(feature = "region-target-https-proxies")]
#[async_trait::async_trait]
pub trait RegionTargetHttpsProxies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_target_https_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_target_https_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>>;

    async fn insert(
        &self,
        req: crate::model::region_target_https_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_target_https_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>>;

    async fn patch(
        &self,
        req: crate::model::region_target_https_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_ssl_certificates(
        &self,
        req: crate::model::region_target_https_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_url_map(
        &self,
        req: crate::model::region_target_https_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionTargetHttpsProxies] also implement [RegionTargetHttpsProxies].
#[cfg(feature = "region-target-https-proxies")]
#[async_trait::async_trait]
impl<T: super::RegionTargetHttpsProxies> RegionTargetHttpsProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_target_https_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_target_https_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_target_https_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_target_https_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_target_https_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_ssl_certificates(
        &self,
        req: crate::model::region_target_https_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_ssl_certificates(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_url_map(
        &self,
        req: crate::model::region_target_https_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_url_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionTargetTcpProxies].
#[cfg(feature = "region-target-tcp-proxies")]
#[async_trait::async_trait]
pub trait RegionTargetTcpProxies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_target_tcp_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_target_tcp_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxy>>;

    async fn insert(
        &self,
        req: crate::model::region_target_tcp_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_target_tcp_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionTargetTcpProxies] also implement [RegionTargetTcpProxies].
#[cfg(feature = "region-target-tcp-proxies")]
#[async_trait::async_trait]
impl<T: super::RegionTargetTcpProxies> RegionTargetTcpProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_target_tcp_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_target_tcp_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_target_tcp_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_target_tcp_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionUrlMaps].
#[cfg(feature = "region-url-maps")]
#[async_trait::async_trait]
pub trait RegionUrlMaps: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::region_url_maps::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::region_url_maps::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMap>>;

    async fn insert(
        &self,
        req: crate::model::region_url_maps::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::region_url_maps::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapList>>;

    async fn patch(
        &self,
        req: crate::model::region_url_maps::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::region_url_maps::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn validate(
        &self,
        req: crate::model::region_url_maps::ValidateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::RegionUrlMaps] also implement [RegionUrlMaps].
#[cfg(feature = "region-url-maps")]
#[async_trait::async_trait]
impl<T: super::RegionUrlMaps> RegionUrlMaps for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::region_url_maps::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::region_url_maps::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMap>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::region_url_maps::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_url_maps::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::region_url_maps::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::region_url_maps::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn validate(
        &self,
        req: crate::model::region_url_maps::ValidateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>> {
        T::validate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::RegionZones].
#[cfg(feature = "region-zones")]
#[async_trait::async_trait]
pub trait RegionZones: std::fmt::Debug + Send + Sync {
    async fn list(
        &self,
        req: crate::model::region_zones::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ZoneList>>;
}

/// All implementations of [super::RegionZones] also implement [RegionZones].
#[cfg(feature = "region-zones")]
#[async_trait::async_trait]
impl<T: super::RegionZones> RegionZones for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::region_zones::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ZoneList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Regions].
#[cfg(feature = "regions")]
#[async_trait::async_trait]
pub trait Regions: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::regions::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Region>>;

    async fn list(
        &self,
        req: crate::model::regions::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionList>>;
}

/// All implementations of [super::Regions] also implement [Regions].
#[cfg(feature = "regions")]
#[async_trait::async_trait]
impl<T: super::Regions> Regions for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::regions::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Region>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::regions::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RegionList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ReservationBlocks].
#[cfg(feature = "reservation-blocks")]
#[async_trait::async_trait]
pub trait ReservationBlocks: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::reservation_blocks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationBlocksGetResponse>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::reservation_blocks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn list(
        &self,
        req: crate::model::reservation_blocks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationBlocksListResponse>>;

    async fn perform_maintenance(
        &self,
        req: crate::model::reservation_blocks::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::reservation_blocks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::reservation_blocks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ReservationBlocks] also implement [ReservationBlocks].
#[cfg(feature = "reservation-blocks")]
#[async_trait::async_trait]
impl<T: super::ReservationBlocks> ReservationBlocks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::reservation_blocks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationBlocksGetResponse>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::reservation_blocks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::reservation_blocks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationBlocksListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_maintenance(
        &self,
        req: crate::model::reservation_blocks::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::perform_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::reservation_blocks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::reservation_blocks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ReservationSubBlocks].
#[cfg(feature = "reservation-sub-blocks")]
#[async_trait::async_trait]
pub trait ReservationSubBlocks: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::reservation_sub_blocks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationSubBlocksGetResponse>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::reservation_sub_blocks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn list(
        &self,
        req: crate::model::reservation_sub_blocks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationSubBlocksListResponse>>;

    async fn perform_maintenance(
        &self,
        req: crate::model::reservation_sub_blocks::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn report_faulty(
        &self,
        req: crate::model::reservation_sub_blocks::ReportFaultyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::reservation_sub_blocks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::reservation_sub_blocks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ReservationSubBlocks] also implement [ReservationSubBlocks].
#[cfg(feature = "reservation-sub-blocks")]
#[async_trait::async_trait]
impl<T: super::ReservationSubBlocks> ReservationSubBlocks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::reservation_sub_blocks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationSubBlocksGetResponse>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::reservation_sub_blocks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::reservation_sub_blocks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationSubBlocksListResponse>>
    {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_maintenance(
        &self,
        req: crate::model::reservation_sub_blocks::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::perform_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn report_faulty(
        &self,
        req: crate::model::reservation_sub_blocks::ReportFaultyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::report_faulty(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::reservation_sub_blocks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::reservation_sub_blocks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Reservations].
#[cfg(feature = "reservations")]
#[async_trait::async_trait]
pub trait Reservations: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::reservations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::reservations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::reservations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Reservation>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::reservations::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::reservations::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::reservations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationList>>;

    async fn perform_maintenance(
        &self,
        req: crate::model::reservations::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn resize(
        &self,
        req: crate::model::reservations::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::reservations::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::reservations::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::reservations::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Reservations] also implement [Reservations].
#[cfg(feature = "reservations")]
#[async_trait::async_trait]
impl<T: super::Reservations> Reservations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::reservations::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::reservations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::reservations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Reservation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::reservations::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::reservations::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::reservations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ReservationList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_maintenance(
        &self,
        req: crate::model::reservations::PerformMaintenanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::perform_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn resize(
        &self,
        req: crate::model::reservations::ResizeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::resize(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::reservations::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::reservations::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::reservations::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ResourcePolicies].
#[cfg(feature = "resource-policies")]
#[async_trait::async_trait]
pub trait ResourcePolicies: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::resource_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicyAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::resource_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::resource_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicy>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::resource_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::resource_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::resource_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicyList>>;

    async fn patch(
        &self,
        req: crate::model::resource_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::resource_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::resource_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ResourcePolicies] also implement [ResourcePolicies].
#[cfg(feature = "resource-policies")]
#[async_trait::async_trait]
impl<T: super::ResourcePolicies> ResourcePolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::resource_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicyAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::resource_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::resource_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::resource_policies::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::resource_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::resource_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ResourcePolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::resource_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::resource_policies::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::resource_policies::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Routers].
#[cfg(feature = "routers")]
#[async_trait::async_trait]
pub trait Routers: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::routers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::routers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn delete_route_policy(
        &self,
        req: crate::model::routers::DeleteRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::routers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Router>>;

    async fn get_nat_ip_info(
        &self,
        req: crate::model::routers::GetNatIpInfoRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NatIpInfoResponse>>;

    async fn get_nat_mapping_info(
        &self,
        req: crate::model::routers::GetNatMappingInfoRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VmEndpointNatMappingsList>>;

    async fn get_route_policy(
        &self,
        req: crate::model::routers::GetRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersGetRoutePolicyResponse>>;

    async fn get_router_status(
        &self,
        req: crate::model::routers::GetRouterStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterStatusResponse>>;

    async fn insert(
        &self,
        req: crate::model::routers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::routers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterList>>;

    async fn list_bgp_routes(
        &self,
        req: crate::model::routers::ListBgpRoutesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersListBgpRoutes>>;

    async fn list_route_policies(
        &self,
        req: crate::model::routers::ListRoutePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersListRoutePolicies>>;

    async fn patch(
        &self,
        req: crate::model::routers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_route_policy(
        &self,
        req: crate::model::routers::PatchRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn preview(
        &self,
        req: crate::model::routers::PreviewRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersPreviewResponse>>;

    async fn update(
        &self,
        req: crate::model::routers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update_route_policy(
        &self,
        req: crate::model::routers::UpdateRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Routers] also implement [Routers].
#[cfg(feature = "routers")]
#[async_trait::async_trait]
impl<T: super::Routers> Routers for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::routers::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::routers::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_route_policy(
        &self,
        req: crate::model::routers::DeleteRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete_route_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::routers::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Router>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_nat_ip_info(
        &self,
        req: crate::model::routers::GetNatIpInfoRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::NatIpInfoResponse>> {
        T::get_nat_ip_info(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_nat_mapping_info(
        &self,
        req: crate::model::routers::GetNatMappingInfoRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VmEndpointNatMappingsList>> {
        T::get_nat_mapping_info(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_route_policy(
        &self,
        req: crate::model::routers::GetRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersGetRoutePolicyResponse>> {
        T::get_route_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_router_status(
        &self,
        req: crate::model::routers::GetRouterStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterStatusResponse>> {
        T::get_router_status(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::routers::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::routers::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouterList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_bgp_routes(
        &self,
        req: crate::model::routers::ListBgpRoutesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersListBgpRoutes>> {
        T::list_bgp_routes(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_route_policies(
        &self,
        req: crate::model::routers::ListRoutePoliciesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersListRoutePolicies>> {
        T::list_route_policies(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::routers::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_route_policy(
        &self,
        req: crate::model::routers::PatchRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_route_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn preview(
        &self,
        req: crate::model::routers::PreviewRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RoutersPreviewResponse>> {
        T::preview(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::routers::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_route_policy(
        &self,
        req: crate::model::routers::UpdateRoutePolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update_route_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Routes].
#[cfg(feature = "routes")]
#[async_trait::async_trait]
pub trait Routes: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::routes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::routes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Route>>;

    async fn insert(
        &self,
        req: crate::model::routes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::routes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouteList>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Routes] also implement [Routes].
#[cfg(feature = "routes")]
#[async_trait::async_trait]
impl<T: super::Routes> Routes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::routes::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::routes::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Route>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::routes::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::routes::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::RouteList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::SecurityPolicies].
#[cfg(feature = "security-policies")]
#[async_trait::async_trait]
pub trait SecurityPolicies: std::fmt::Debug + Send + Sync {
    async fn add_rule(
        &self,
        req: crate::model::security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::security_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPoliciesAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>>;

    async fn get_rule(
        &self,
        req: crate::model::security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>;

    async fn insert(
        &self,
        req: crate::model::security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>;

    async fn list_preconfigured_expression_sets(
        &self,
        req: crate::model::security_policies::ListPreconfiguredExpressionSetsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
        >,
    >;

    async fn patch(
        &self,
        req: crate::model::security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn patch_rule(
        &self,
        req: crate::model::security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_rule(
        &self,
        req: crate::model::security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_labels(
        &self,
        req: crate::model::security_policies::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::SecurityPolicies] also implement [SecurityPolicies].
#[cfg(feature = "security-policies")]
#[async_trait::async_trait]
impl<T: super::SecurityPolicies> SecurityPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_rule(
        &self,
        req: crate::model::security_policies::AddRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::security_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPoliciesAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::security_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::security_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_rule(
        &self,
        req: crate::model::security_policies::GetRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>> {
        T::get_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::security_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::security_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SecurityPolicyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_preconfigured_expression_sets(
        &self,
        req: crate::model::security_policies::ListPreconfiguredExpressionSetsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<
            crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
        >,
    > {
        T::list_preconfigured_expression_sets(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::security_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch_rule(
        &self,
        req: crate::model::security_policies::PatchRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_rule(
        &self,
        req: crate::model::security_policies::RemoveRuleRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_rule(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::security_policies::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ServiceAttachments].
#[cfg(feature = "service-attachments")]
#[async_trait::async_trait]
pub trait ServiceAttachments: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::service_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachmentAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::service_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::service_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachment>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::service_attachments::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::service_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::service_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachmentList>>;

    async fn patch(
        &self,
        req: crate::model::service_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::service_attachments::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::service_attachments::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::ServiceAttachments] also implement [ServiceAttachments].
#[cfg(feature = "service-attachments")]
#[async_trait::async_trait]
impl<T: super::ServiceAttachments> ServiceAttachments for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::service_attachments::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachmentAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::service_attachments::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::service_attachments::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachment>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::service_attachments::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::service_attachments::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::service_attachments::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ServiceAttachmentList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::service_attachments::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::service_attachments::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::service_attachments::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::SnapshotSettings].
#[cfg(feature = "snapshot-settings")]
#[async_trait::async_trait]
pub trait SnapshotSettings: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::snapshot_settings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SnapshotSettings>>;

    async fn patch(
        &self,
        req: crate::model::snapshot_settings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::SnapshotSettings] also implement [SnapshotSettings].
#[cfg(feature = "snapshot-settings")]
#[async_trait::async_trait]
impl<T: super::SnapshotSettings> SnapshotSettings for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::snapshot_settings::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SnapshotSettings>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::snapshot_settings::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Snapshots].
#[cfg(feature = "snapshots")]
#[async_trait::async_trait]
pub trait Snapshots: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Snapshot>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SnapshotList>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_labels(
        &self,
        req: crate::model::snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Snapshots] also implement [Snapshots].
#[cfg(feature = "snapshots")]
#[async_trait::async_trait]
impl<T: super::Snapshots> Snapshots for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::snapshots::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::snapshots::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Snapshot>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::snapshots::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::snapshots::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::snapshots::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SnapshotList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::snapshots::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::snapshots::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::snapshots::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::SslCertificates].
#[cfg(feature = "ssl-certificates")]
#[async_trait::async_trait]
pub trait SslCertificates: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::ssl_certificates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::ssl_certificates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::ssl_certificates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificate>>;

    async fn insert(
        &self,
        req: crate::model::ssl_certificates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::ssl_certificates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateList>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::SslCertificates] also implement [SslCertificates].
#[cfg(feature = "ssl-certificates")]
#[async_trait::async_trait]
impl<T: super::SslCertificates> SslCertificates for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::ssl_certificates::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::ssl_certificates::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::ssl_certificates::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificate>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::ssl_certificates::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::ssl_certificates::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslCertificateList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::SslPolicies].
#[cfg(feature = "ssl-policies")]
#[async_trait::async_trait]
pub trait SslPolicies: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::ssl_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::ssl_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::ssl_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPolicy>>;

    async fn insert(
        &self,
        req: crate::model::ssl_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::ssl_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesList>>;

    async fn list_available_features(
        &self,
        req: crate::model::ssl_policies::ListAvailableFeaturesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
    >;

    async fn patch(
        &self,
        req: crate::model::ssl_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::SslPolicies] also implement [SslPolicies].
#[cfg(feature = "ssl-policies")]
#[async_trait::async_trait]
impl<T: super::SslPolicies> SslPolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::ssl_policies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::ssl_policies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::ssl_policies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::ssl_policies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::ssl_policies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SslPoliciesList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_available_features(
        &self,
        req: crate::model::ssl_policies::ListAvailableFeaturesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<
        gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
    > {
        T::list_available_features(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::ssl_policies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::StoragePoolTypes].
#[cfg(feature = "storage-pool-types")]
#[async_trait::async_trait]
pub trait StoragePoolTypes: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::storage_pool_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolTypeAggregatedList>>;

    async fn get(
        &self,
        req: crate::model::storage_pool_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolType>>;

    async fn list(
        &self,
        req: crate::model::storage_pool_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolTypeList>>;
}

/// All implementations of [super::StoragePoolTypes] also implement [StoragePoolTypes].
#[cfg(feature = "storage-pool-types")]
#[async_trait::async_trait]
impl<T: super::StoragePoolTypes> StoragePoolTypes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::storage_pool_types::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolTypeAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::storage_pool_types::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolType>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::storage_pool_types::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolTypeList>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::StoragePools].
#[cfg(feature = "storage-pools")]
#[async_trait::async_trait]
pub trait StoragePools: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::storage_pools::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::storage_pools::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::storage_pools::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePool>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::storage_pools::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::storage_pools::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::storage_pools::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolList>>;

    async fn list_disks(
        &self,
        req: crate::model::storage_pools::ListDisksRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolListDisks>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::storage_pools::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::storage_pools::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::storage_pools::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::StoragePools] also implement [StoragePools].
#[cfg(feature = "storage-pools")]
#[async_trait::async_trait]
impl<T: super::StoragePools> StoragePools for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::storage_pools::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::storage_pools::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::storage_pools::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePool>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::storage_pools::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::storage_pools::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::storage_pools::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_disks(
        &self,
        req: crate::model::storage_pools::ListDisksRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::StoragePoolListDisks>> {
        T::list_disks(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::storage_pools::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::storage_pools::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::storage_pools::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Subnetworks].
#[cfg(feature = "subnetworks")]
#[async_trait::async_trait]
pub trait Subnetworks: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::subnetworks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SubnetworkAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::subnetworks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn expand_ip_cidr_range(
        &self,
        req: crate::model::subnetworks::ExpandIpCidrRangeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::subnetworks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Subnetwork>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::subnetworks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn insert(
        &self,
        req: crate::model::subnetworks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::subnetworks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SubnetworkList>>;

    async fn list_usable(
        &self,
        req: crate::model::subnetworks::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UsableSubnetworksAggregatedList>>;

    async fn patch(
        &self,
        req: crate::model::subnetworks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::subnetworks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>>;

    async fn set_private_ip_google_access(
        &self,
        req: crate::model::subnetworks::SetPrivateIpGoogleAccessRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::subnetworks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::Subnetworks] also implement [Subnetworks].
#[cfg(feature = "subnetworks")]
#[async_trait::async_trait]
impl<T: super::Subnetworks> Subnetworks for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::subnetworks::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SubnetworkAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::subnetworks::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn expand_ip_cidr_range(
        &self,
        req: crate::model::subnetworks::ExpandIpCidrRangeRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::expand_ip_cidr_range(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::subnetworks::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Subnetwork>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::subnetworks::GetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::subnetworks::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::subnetworks::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::SubnetworkList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_usable(
        &self,
        req: crate::model::subnetworks::ListUsableRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UsableSubnetworksAggregatedList>> {
        T::list_usable(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::subnetworks::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::subnetworks::SetIamPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_private_ip_google_access(
        &self,
        req: crate::model::subnetworks::SetPrivateIpGoogleAccessRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_private_ip_google_access(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::subnetworks::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetGrpcProxies].
#[cfg(feature = "target-grpc-proxies")]
#[async_trait::async_trait]
pub trait TargetGrpcProxies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::target_grpc_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_grpc_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetGrpcProxy>>;

    async fn insert(
        &self,
        req: crate::model::target_grpc_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_grpc_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetGrpcProxyList>>;

    async fn patch(
        &self,
        req: crate::model::target_grpc_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetGrpcProxies] also implement [TargetGrpcProxies].
#[cfg(feature = "target-grpc-proxies")]
#[async_trait::async_trait]
impl<T: super::TargetGrpcProxies> TargetGrpcProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_grpc_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_grpc_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetGrpcProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_grpc_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_grpc_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetGrpcProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::target_grpc_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetHttpProxies].
#[cfg(feature = "target-http-proxies")]
#[async_trait::async_trait]
pub trait TargetHttpProxies: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::target_http_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_http_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_http_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxy>>;

    async fn insert(
        &self,
        req: crate::model::target_http_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_http_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>>;

    async fn patch(
        &self,
        req: crate::model::target_http_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_url_map(
        &self,
        req: crate::model::target_http_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetHttpProxies] also implement [TargetHttpProxies].
#[cfg(feature = "target-http-proxies")]
#[async_trait::async_trait]
impl<T: super::TargetHttpProxies> TargetHttpProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_http_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_http_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_http_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_http_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_http_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::target_http_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_url_map(
        &self,
        req: crate::model::target_http_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_url_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetHttpsProxies].
#[cfg(feature = "target-https-proxies")]
#[async_trait::async_trait]
pub trait TargetHttpsProxies: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::target_https_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_https_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_https_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>>;

    async fn insert(
        &self,
        req: crate::model::target_https_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_https_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>>;

    async fn patch(
        &self,
        req: crate::model::target_https_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_certificate_map(
        &self,
        req: crate::model::target_https_proxies::SetCertificateMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_quic_override(
        &self,
        req: crate::model::target_https_proxies::SetQuicOverrideRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_ssl_certificates(
        &self,
        req: crate::model::target_https_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_ssl_policy(
        &self,
        req: crate::model::target_https_proxies::SetSslPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_url_map(
        &self,
        req: crate::model::target_https_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetHttpsProxies] also implement [TargetHttpsProxies].
#[cfg(feature = "target-https-proxies")]
#[async_trait::async_trait]
impl<T: super::TargetHttpsProxies> TargetHttpsProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_https_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_https_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_https_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_https_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_https_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::target_https_proxies::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_certificate_map(
        &self,
        req: crate::model::target_https_proxies::SetCertificateMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_certificate_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_quic_override(
        &self,
        req: crate::model::target_https_proxies::SetQuicOverrideRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_quic_override(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_ssl_certificates(
        &self,
        req: crate::model::target_https_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_ssl_certificates(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_ssl_policy(
        &self,
        req: crate::model::target_https_proxies::SetSslPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_ssl_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_url_map(
        &self,
        req: crate::model::target_https_proxies::SetUrlMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_url_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetInstances].
#[cfg(feature = "target-instances")]
#[async_trait::async_trait]
pub trait TargetInstances: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::target_instances::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstanceAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_instances::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_instances::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstance>>;

    async fn insert(
        &self,
        req: crate::model::target_instances::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_instances::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstanceList>>;

    async fn set_security_policy(
        &self,
        req: crate::model::target_instances::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::target_instances::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetInstances] also implement [TargetInstances].
#[cfg(feature = "target-instances")]
#[async_trait::async_trait]
impl<T: super::TargetInstances> TargetInstances for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_instances::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstanceAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_instances::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_instances::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstance>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_instances::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_instances::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetInstanceList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_security_policy(
        &self,
        req: crate::model::target_instances::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::target_instances::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetPools].
#[cfg(feature = "target-pools")]
#[async_trait::async_trait]
pub trait TargetPools: std::fmt::Debug + Send + Sync {
    async fn add_health_check(
        &self,
        req: crate::model::target_pools::AddHealthCheckRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn add_instance(
        &self,
        req: crate::model::target_pools::AddInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn aggregated_list(
        &self,
        req: crate::model::target_pools::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_pools::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_pools::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPool>>;

    async fn get_health(
        &self,
        req: crate::model::target_pools::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolInstanceHealth>>;

    async fn insert(
        &self,
        req: crate::model::target_pools::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_pools::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolList>>;

    async fn remove_health_check(
        &self,
        req: crate::model::target_pools::RemoveHealthCheckRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn remove_instance(
        &self,
        req: crate::model::target_pools::RemoveInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_backup(
        &self,
        req: crate::model::target_pools::SetBackupRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_security_policy(
        &self,
        req: crate::model::target_pools::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::target_pools::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetPools] also implement [TargetPools].
#[cfg(feature = "target-pools")]
#[async_trait::async_trait]
impl<T: super::TargetPools> TargetPools for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_health_check(
        &self,
        req: crate::model::target_pools::AddHealthCheckRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_health_check(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_instance(
        &self,
        req: crate::model::target_pools::AddInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::add_instance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_pools::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_pools::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_pools::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPool>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_health(
        &self,
        req: crate::model::target_pools::GetHealthRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolInstanceHealth>> {
        T::get_health(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_pools::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_pools::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetPoolList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_health_check(
        &self,
        req: crate::model::target_pools::RemoveHealthCheckRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_health_check(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn remove_instance(
        &self,
        req: crate::model::target_pools::RemoveInstanceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::remove_instance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_backup(
        &self,
        req: crate::model::target_pools::SetBackupRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_backup(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_security_policy(
        &self,
        req: crate::model::target_pools::SetSecurityPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_security_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::target_pools::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetSslProxies].
#[cfg(feature = "target-ssl-proxies")]
#[async_trait::async_trait]
pub trait TargetSslProxies: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::target_ssl_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_ssl_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetSslProxy>>;

    async fn insert(
        &self,
        req: crate::model::target_ssl_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_ssl_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetSslProxyList>>;

    async fn set_backend_service(
        &self,
        req: crate::model::target_ssl_proxies::SetBackendServiceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_certificate_map(
        &self,
        req: crate::model::target_ssl_proxies::SetCertificateMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_proxy_header(
        &self,
        req: crate::model::target_ssl_proxies::SetProxyHeaderRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_ssl_certificates(
        &self,
        req: crate::model::target_ssl_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_ssl_policy(
        &self,
        req: crate::model::target_ssl_proxies::SetSslPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetSslProxies] also implement [TargetSslProxies].
#[cfg(feature = "target-ssl-proxies")]
#[async_trait::async_trait]
impl<T: super::TargetSslProxies> TargetSslProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_ssl_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_ssl_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetSslProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_ssl_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_ssl_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetSslProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_backend_service(
        &self,
        req: crate::model::target_ssl_proxies::SetBackendServiceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_backend_service(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_certificate_map(
        &self,
        req: crate::model::target_ssl_proxies::SetCertificateMapRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_certificate_map(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_proxy_header(
        &self,
        req: crate::model::target_ssl_proxies::SetProxyHeaderRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_proxy_header(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_ssl_certificates(
        &self,
        req: crate::model::target_ssl_proxies::SetSslCertificatesRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_ssl_certificates(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_ssl_policy(
        &self,
        req: crate::model::target_ssl_proxies::SetSslPolicyRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_ssl_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetTcpProxies].
#[cfg(feature = "target-tcp-proxies")]
#[async_trait::async_trait]
pub trait TargetTcpProxies: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::target_tcp_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_tcp_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_tcp_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxy>>;

    async fn insert(
        &self,
        req: crate::model::target_tcp_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_tcp_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>>;

    async fn set_backend_service(
        &self,
        req: crate::model::target_tcp_proxies::SetBackendServiceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn set_proxy_header(
        &self,
        req: crate::model::target_tcp_proxies::SetProxyHeaderRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetTcpProxies] also implement [TargetTcpProxies].
#[cfg(feature = "target-tcp-proxies")]
#[async_trait::async_trait]
impl<T: super::TargetTcpProxies> TargetTcpProxies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_tcp_proxies::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_tcp_proxies::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_tcp_proxies::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_tcp_proxies::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_tcp_proxies::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_backend_service(
        &self,
        req: crate::model::target_tcp_proxies::SetBackendServiceRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_backend_service(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_proxy_header(
        &self,
        req: crate::model::target_tcp_proxies::SetProxyHeaderRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_proxy_header(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::TargetVpnGateways].
#[cfg(feature = "target-vpn-gateways")]
#[async_trait::async_trait]
pub trait TargetVpnGateways: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::target_vpn_gateways::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGatewayAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::target_vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::target_vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGateway>>;

    async fn insert(
        &self,
        req: crate::model::target_vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::target_vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGatewayList>>;

    async fn set_labels(
        &self,
        req: crate::model::target_vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::TargetVpnGateways] also implement [TargetVpnGateways].
#[cfg(feature = "target-vpn-gateways")]
#[async_trait::async_trait]
impl<T: super::TargetVpnGateways> TargetVpnGateways for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::target_vpn_gateways::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGatewayAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::target_vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::target_vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGateway>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::target_vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::target_vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TargetVpnGatewayList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::target_vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::UrlMaps].
#[cfg(feature = "url-maps")]
#[async_trait::async_trait]
pub trait UrlMaps: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::url_maps::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::url_maps::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::url_maps::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMap>>;

    async fn insert(
        &self,
        req: crate::model::url_maps::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn invalidate_cache(
        &self,
        req: crate::model::url_maps::InvalidateCacheRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::url_maps::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapList>>;

    async fn patch(
        &self,
        req: crate::model::url_maps::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::url_maps::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn validate(
        &self,
        req: crate::model::url_maps::ValidateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::UrlMaps] also implement [UrlMaps].
#[cfg(feature = "url-maps")]
#[async_trait::async_trait]
impl<T: super::UrlMaps> UrlMaps for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::url_maps::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::url_maps::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::url_maps::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMap>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::url_maps::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn invalidate_cache(
        &self,
        req: crate::model::url_maps::InvalidateCacheRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::invalidate_cache(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::url_maps::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::url_maps::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::url_maps::UpdateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn validate(
        &self,
        req: crate::model::url_maps::ValidateRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>> {
        T::validate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::VpnGateways].
#[cfg(feature = "vpn-gateways")]
#[async_trait::async_trait]
pub trait VpnGateways: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::vpn_gateways::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewayAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGateway>>;

    async fn get_status(
        &self,
        req: crate::model::vpn_gateways::GetStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewaysGetStatusResponse>>;

    async fn insert(
        &self,
        req: crate::model::vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewayList>>;

    async fn set_labels(
        &self,
        req: crate::model::vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::vpn_gateways::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::VpnGateways] also implement [VpnGateways].
#[cfg(feature = "vpn-gateways")]
#[async_trait::async_trait]
impl<T: super::VpnGateways> VpnGateways for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::vpn_gateways::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewayAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::vpn_gateways::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::vpn_gateways::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGateway>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_status(
        &self,
        req: crate::model::vpn_gateways::GetStatusRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewaysGetStatusResponse>> {
        T::get_status(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::vpn_gateways::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::vpn_gateways::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnGatewayList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::vpn_gateways::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::vpn_gateways::TestIamPermissionsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::VpnTunnels].
#[cfg(feature = "vpn-tunnels")]
#[async_trait::async_trait]
pub trait VpnTunnels: std::fmt::Debug + Send + Sync {
    async fn aggregated_list(
        &self,
        req: crate::model::vpn_tunnels::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnelAggregatedList>>;

    async fn delete(
        &self,
        req: crate::model::vpn_tunnels::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::vpn_tunnels::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnel>>;

    async fn insert(
        &self,
        req: crate::model::vpn_tunnels::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::vpn_tunnels::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnelList>>;

    async fn set_labels(
        &self,
        req: crate::model::vpn_tunnels::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::VpnTunnels] also implement [VpnTunnels].
#[cfg(feature = "vpn-tunnels")]
#[async_trait::async_trait]
impl<T: super::VpnTunnels> VpnTunnels for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn aggregated_list(
        &self,
        req: crate::model::vpn_tunnels::AggregatedListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnelAggregatedList>> {
        T::aggregated_list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::vpn_tunnels::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::vpn_tunnels::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnel>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::vpn_tunnels::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::vpn_tunnels::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::VpnTunnelList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_labels(
        &self,
        req: crate::model::vpn_tunnels::SetLabelsRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::set_labels(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::region_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::WireGroups].
#[cfg(feature = "wire-groups")]
#[async_trait::async_trait]
pub trait WireGroups: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::wire_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::wire_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::WireGroup>>;

    async fn insert(
        &self,
        req: crate::model::wire_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::wire_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::WireGroupList>>;

    async fn patch(
        &self,
        req: crate::model::wire_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
}

/// All implementations of [super::WireGroups] also implement [WireGroups].
#[cfg(feature = "wire-groups")]
#[async_trait::async_trait]
impl<T: super::WireGroups> WireGroups for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::wire_groups::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::wire_groups::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::WireGroup>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::wire_groups::InsertRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::wire_groups::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::WireGroupList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::wire_groups::PatchRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::global_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::ZoneOperations].
#[cfg(feature = "zone-operations")]
#[async_trait::async_trait]
pub trait ZoneOperations: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::zone_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>>;

    async fn get(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::zone_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>>;

    async fn wait(
        &self,
        req: crate::model::zone_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;
}

/// All implementations of [super::ZoneOperations] also implement [ZoneOperations].
#[cfg(feature = "zone-operations")]
#[async_trait::async_trait]
impl<T: super::ZoneOperations> ZoneOperations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::zone_operations::DeleteRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<wkt::Empty>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::zone_operations::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::zone_operations::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::OperationList>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn wait(
        &self,
        req: crate::model::zone_operations::WaitRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
        T::wait(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Zones].
#[cfg(feature = "zones")]
#[async_trait::async_trait]
pub trait Zones: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::zones::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Zone>>;

    async fn list(
        &self,
        req: crate::model::zones::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ZoneList>>;
}

/// All implementations of [super::Zones] also implement [Zones].
#[cfg(feature = "zones")]
#[async_trait::async_trait]
impl<T: super::Zones> Zones for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::zones::GetRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::Zone>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::zones::ListRequest,
        options: gax::options::RequestOptions,
    ) -> crate::Result<gax::response::Response<crate::model::ZoneList>> {
        T::list(self, req, options).await
    }
}
